LCOV - code coverage report
Current view: top level - libavcodec - svq1enc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 358 380 94.2 %
Date: 2017-12-16 13:57:32 Functions: 8 8 100.0 %

          Line data    Source code
       1             : /*
       2             :  * SVQ1 Encoder
       3             :  * Copyright (C) 2004 Mike Melanson <melanson@pcisys.net>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * Sorenson Vector Quantizer #1 (SVQ1) video codec.
      25             :  * For more information of the SVQ1 algorithm, visit:
      26             :  *   http://www.pcisys.net/~melanson/codecs/
      27             :  */
      28             : 
      29             : #include "avcodec.h"
      30             : #include "hpeldsp.h"
      31             : #include "me_cmp.h"
      32             : #include "mpegvideo.h"
      33             : #include "h263.h"
      34             : #include "internal.h"
      35             : #include "mpegutils.h"
      36             : #include "svq1.h"
      37             : #include "svq1enc.h"
      38             : #include "svq1enc_cb.h"
      39             : #include "libavutil/avassert.h"
      40             : 
      41             : 
      42         200 : static void svq1_write_header(SVQ1EncContext *s, int frame_type)
      43             : {
      44             :     int i;
      45             : 
      46             :     /* frame code */
      47         200 :     put_bits(&s->pb, 22, 0x20);
      48             : 
      49             :     /* temporal reference (sure hope this is a "don't care") */
      50         200 :     put_bits(&s->pb, 8, 0x00);
      51             : 
      52             :     /* frame type */
      53         200 :     put_bits(&s->pb, 2, frame_type - 1);
      54             : 
      55         200 :     if (frame_type == AV_PICTURE_TYPE_I) {
      56             :         /* no checksum since frame code is 0x20 */
      57             :         /* no embedded string either */
      58             :         /* output 5 unknown bits (2 + 2 + 1) */
      59          20 :         put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */
      60             : 
      61          20 :         i = ff_match_2uint16((void*)ff_svq1_frame_size_table,
      62             :                              FF_ARRAY_ELEMS(ff_svq1_frame_size_table),
      63             :                              s->frame_width, s->frame_height);
      64          20 :         put_bits(&s->pb, 3, i);
      65             : 
      66          20 :         if (i == 7) {
      67           5 :             put_bits(&s->pb, 12, s->frame_width);
      68           5 :             put_bits(&s->pb, 12, s->frame_height);
      69             :         }
      70             :     }
      71             : 
      72             :     /* no checksum or extra data (next 2 bits get 0) */
      73         200 :     put_bits(&s->pb, 2, 0);
      74         200 : }
      75             : 
      76             : #define QUALITY_THRESHOLD    100
      77             : #define THRESHOLD_MULTIPLIER 0.6
      78             : 
      79   393187392 : static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
      80             :                                intptr_t size)
      81             : {
      82   393187392 :     int score = 0, i;
      83             : 
      84  7128095808 :     for (i = 0; i < size; i++)
      85  6734908416 :         score += (pix1[i] - pix2[i]) * (pix1[i] - pix2[i]);
      86   393187392 :     return score;
      87             : }
      88             : 
      89     4302520 : static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,
      90             :                         uint8_t *decoded, int stride, int level,
      91             :                         int threshold, int lambda, int intra)
      92             : {
      93             :     int count, y, x, i, j, split, best_mean, best_score, best_count;
      94             :     int best_vector[6];
      95     4302520 :     int block_sum[7] = { 0, 0, 0, 0, 0, 0 };
      96     4302520 :     int w            = 2 << (level + 2 >> 1);
      97     4302520 :     int h            = 2 << (level + 1 >> 1);
      98     4302520 :     int size         = w * h;
      99     4302520 :     int16_t (*block)[256] = s->encoded_block_levels[level];
     100             :     const int8_t *codebook_sum, *codebook;
     101             :     const uint16_t(*mean_vlc)[2];
     102             :     const uint8_t(*multistage_vlc)[2];
     103             : 
     104     4302520 :     best_score = 0;
     105             :     // FIXME: Optimize, this does not need to be done multiple times.
     106     4302520 :     if (intra) {
     107             :         // level is 5 when encode_block is called from svq1_encode_plane
     108             :         // and always < 4 when called recursively from this function.
     109      643967 :         codebook_sum   = level < 4 ? svq1_intra_codebook_sum[level] : NULL;
     110      643967 :         codebook       = ff_svq1_intra_codebooks[level];
     111      643967 :         mean_vlc       = ff_svq1_intra_mean_vlc;
     112      643967 :         multistage_vlc = ff_svq1_intra_multistage_vlc[level];
     113     2941539 :         for (y = 0; y < h; y++) {
     114    18101876 :             for (x = 0; x < w; x++) {
     115    15804304 :                 int v = src[x + y * stride];
     116    15804304 :                 block[0][x + w * y] = v;
     117    15804304 :                 best_score         += v * v;
     118    15804304 :                 block_sum[0]       += v;
     119             :             }
     120             :         }
     121             :     } else {
     122             :         // level is 5 or < 4, see above for details.
     123     3658553 :         codebook_sum   = level < 4 ? svq1_inter_codebook_sum[level] : NULL;
     124     3658553 :         codebook       = ff_svq1_inter_codebooks[level];
     125     3658553 :         mean_vlc       = ff_svq1_inter_mean_vlc + 256;
     126     3658553 :         multistage_vlc = ff_svq1_inter_multistage_vlc[level];
     127    16702413 :         for (y = 0; y < h; y++) {
     128   102693156 :             for (x = 0; x < w; x++) {
     129    89649296 :                 int v = src[x + y * stride] - ref[x + y * stride];
     130    89649296 :                 block[0][x + w * y] = v;
     131    89649296 :                 best_score         += v * v;
     132    89649296 :                 block_sum[0]       += v;
     133             :             }
     134             :         }
     135             :     }
     136             : 
     137     4302520 :     best_count  = 0;
     138     4302520 :     best_score -= (int)((unsigned)block_sum[0] * block_sum[0] >> (level + 3));
     139     4302520 :     best_mean   = block_sum[0] + (size >> 1) >> (level + 3);
     140             : 
     141     4302520 :     if (level < 4) {
     142    28669914 :         for (count = 1; count < 7; count++) {
     143    24574212 :             int best_vector_score = INT_MAX;
     144    24574212 :             int best_vector_sum   = -999, best_vector_mean = -999;
     145    24574212 :             const int stage       = count - 1;
     146             :             const int8_t *vector;
     147             : 
     148   417761604 :             for (i = 0; i < 16; i++) {
     149   393187392 :                 int sum = codebook_sum[stage * 16 + i];
     150             :                 int sqr, diff, score;
     151             : 
     152   393187392 :                 vector = codebook + stage * size * 16 + i * size;
     153   393187392 :                 sqr    = s->ssd_int8_vs_int16(vector, block[stage], size);
     154   393187392 :                 diff   = block_sum[stage] - sum;
     155   393187392 :                 score  = sqr - (diff * (int64_t)diff >> (level + 3)); // FIXME: 64 bits slooow
     156   393187392 :                 if (score < best_vector_score) {
     157    65429340 :                     int mean = diff + (size >> 1) >> (level + 3);
     158             :                     av_assert2(mean > -300 && mean < 300);
     159    65429340 :                     mean               = av_clip(mean, intra ? 0 : -256, 255);
     160    65429340 :                     best_vector_score  = score;
     161    65429340 :                     best_vector[stage] = i;
     162    65429340 :                     best_vector_sum    = sum;
     163    65429340 :                     best_vector_mean   = mean;
     164             :                 }
     165             :             }
     166    24574212 :             av_assert0(best_vector_mean != -999);
     167    24574212 :             vector = codebook + stage * size * 16 + best_vector[stage] * size;
     168   445505988 :             for (j = 0; j < size; j++)
     169   420931776 :                 block[stage + 1][j] = block[stage][j] - vector[j];
     170    24574212 :             block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
     171    24574212 :             best_vector_score   += lambda *
     172    49148424 :                                    (+1 + 4 * count +
     173    24574212 :                                     multistage_vlc[1 + count][1]
     174    24574212 :                                     + mean_vlc[best_vector_mean][1]);
     175             : 
     176    24574212 :             if (best_vector_score < best_score) {
     177     5418702 :                 best_score = best_vector_score;
     178     5418702 :                 best_count = count;
     179     5418702 :                 best_mean  = best_vector_mean;
     180             :             }
     181             :         }
     182             :     }
     183             : 
     184     4302520 :     split = 0;
     185     4302520 :     if (best_score > threshold && level) {
     186     2116785 :         int score  = 0;
     187     2116785 :         int offset = level & 1 ? stride * h / 2 : w / 2;
     188             :         PutBitContext backup[6];
     189             : 
     190     6020163 :         for (i = level - 1; i >= 0; i--)
     191     3903378 :             backup[i] = s->reorder_pb[i];
     192     2116785 :         score += encode_block(s, src, ref, decoded, stride, level - 1,
     193             :                               threshold >> 1, lambda, intra);
     194     2116785 :         score += encode_block(s, src + offset, ref + offset, decoded + offset,
     195             :                               stride, level - 1, threshold >> 1, lambda, intra);
     196     2116785 :         score += lambda;
     197             : 
     198     2116785 :         if (score < best_score) {
     199     1359022 :             best_score = score;
     200     1359022 :             split      = 1;
     201             :         } else {
     202     1804497 :             for (i = level - 1; i >= 0; i--)
     203     1046734 :                 s->reorder_pb[i] = backup[i];
     204             :         }
     205             :     }
     206     4302520 :     if (level > 0)
     207     2127648 :         put_bits(&s->reorder_pb[level], 1, split);
     208             : 
     209     4302520 :     if (!split) {
     210             :         av_assert1(best_mean >= 0 && best_mean < 256 || !intra);
     211             :         av_assert1(best_mean >= -256 && best_mean < 256);
     212             :         av_assert1(best_count >= 0 && best_count < 7);
     213             :         av_assert1(level < 4 || best_count == 0);
     214             : 
     215             :         /* output the encoding */
     216     5886996 :         put_bits(&s->reorder_pb[level],
     217     2943498 :                  multistage_vlc[1 + best_count][1],
     218     2943498 :                  multistage_vlc[1 + best_count][0]);
     219     2943498 :         put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
     220     2943498 :                  mean_vlc[best_mean][0]);
     221             : 
     222     6593260 :         for (i = 0; i < best_count; i++) {
     223             :             av_assert2(best_vector[i] >= 0 && best_vector[i] < 16);
     224     3649762 :             put_bits(&s->reorder_pb[level], 4, best_vector[i]);
     225             :         }
     226             : 
     227    10625782 :         for (y = 0; y < h; y++)
     228    43895628 :             for (x = 0; x < w; x++)
     229   144853376 :                 decoded[x + y * stride] = src[x + y * stride] -
     230   108640032 :                                           block[best_count][x + w * y] +
     231             :                                           best_mean;
     232             :     }
     233             : 
     234     4302520 :     return best_score;
     235             : }
     236             : 
     237      131005 : static void init_block_index(MpegEncContext *s){
     238      131005 :     s->block_index[0]= s->b8_stride*(s->mb_y*2    )     + s->mb_x*2;
     239      131005 :     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) + 1 + s->mb_x*2;
     240      131005 :     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1)     + s->mb_x*2;
     241      131005 :     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) + 1 + s->mb_x*2;
     242      131005 :     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x;
     243      131005 :     s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x;
     244      131005 : }
     245             : 
     246         600 : static int svq1_encode_plane(SVQ1EncContext *s, int plane,
     247             :                              unsigned char *src_plane,
     248             :                              unsigned char *ref_plane,
     249             :                              unsigned char *decoded_plane,
     250             :                              int width, int height, int src_stride, int stride)
     251             : {
     252             :     int x, y;
     253             :     int i;
     254             :     int block_width, block_height;
     255             :     int level;
     256             :     int threshold[6];
     257         600 :     uint8_t *src     = s->scratchbuf + stride * 32;
     258         600 :     const int lambda = (s->quality * s->quality) >>
     259             :                        (2 * FF_LAMBDA_SHIFT);
     260             : 
     261             :     /* figure out the acceptable level thresholds in advance */
     262         600 :     threshold[5] = QUALITY_THRESHOLD;
     263        3600 :     for (level = 4; level >= 0; level--)
     264        3000 :         threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
     265             : 
     266         600 :     block_width  = (width  + 15) / 16;
     267         600 :     block_height = (height + 15) / 16;
     268             : 
     269         600 :     if (s->pict_type == AV_PICTURE_TYPE_P) {
     270         540 :         s->m.avctx                         = s->avctx;
     271         540 :         s->m.current_picture_ptr           = &s->m.current_picture;
     272         540 :         s->m.last_picture_ptr              = &s->m.last_picture;
     273         540 :         s->m.last_picture.f->data[0]        = ref_plane;
     274         540 :         s->m.linesize                      =
     275        1080 :         s->m.last_picture.f->linesize[0]    =
     276        1620 :         s->m.new_picture.f->linesize[0]     =
     277        1080 :         s->m.current_picture.f->linesize[0] = stride;
     278         540 :         s->m.width                         = width;
     279         540 :         s->m.height                        = height;
     280         540 :         s->m.mb_width                      = block_width;
     281         540 :         s->m.mb_height                     = block_height;
     282         540 :         s->m.mb_stride                     = s->m.mb_width + 1;
     283         540 :         s->m.b8_stride                     = 2 * s->m.mb_width + 1;
     284         540 :         s->m.f_code                        = 1;
     285         540 :         s->m.pict_type                     = s->pict_type;
     286         540 :         s->m.motion_est                    = s->motion_est;
     287         540 :         s->m.me.scene_change_score         = 0;
     288             :         // s->m.out_format                    = FMT_H263;
     289             :         // s->m.unrestricted_mv               = 1;
     290         540 :         s->m.lambda                        = s->quality;
     291        1080 :         s->m.qscale                        = s->m.lambda * 139 +
     292         540 :                                              FF_LAMBDA_SCALE * 64 >>
     293             :                                              FF_LAMBDA_SHIFT + 7;
     294        1080 :         s->m.lambda2                       = s->m.lambda * s->m.lambda +
     295         540 :                                              FF_LAMBDA_SCALE / 2 >>
     296             :                                              FF_LAMBDA_SHIFT;
     297             : 
     298         540 :         if (!s->motion_val8[plane]) {
     299          24 :             s->motion_val8[plane]  = av_mallocz((s->m.b8_stride *
     300          12 :                                                  block_height * 2 + 2) *
     301             :                                                 2 * sizeof(int16_t));
     302          36 :             s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
     303          24 :                                                  (block_height + 2) + 1) *
     304             :                                                 2 * sizeof(int16_t));
     305          12 :             if (!s->motion_val8[plane] || !s->motion_val16[plane])
     306           0 :                 return AVERROR(ENOMEM);
     307             :         }
     308             : 
     309         540 :         s->m.mb_type = s->mb_type;
     310             : 
     311             :         // dummies, to avoid segfaults
     312         540 :         s->m.current_picture.mb_mean   = (uint8_t *)s->dummy;
     313         540 :         s->m.current_picture.mb_var    = (uint16_t *)s->dummy;
     314         540 :         s->m.current_picture.mc_mb_var = (uint16_t *)s->dummy;
     315         540 :         s->m.current_picture.mb_type = s->dummy;
     316             : 
     317         540 :         s->m.current_picture.motion_val[0]   = s->motion_val8[plane] + 2;
     318        1080 :         s->m.p_mv_table                      = s->motion_val16[plane] +
     319         540 :                                                s->m.mb_stride + 1;
     320         540 :         s->m.mecc                            = s->mecc; // move
     321         540 :         ff_init_me(&s->m);
     322             : 
     323         540 :         s->m.me.dia_size      = s->avctx->dia_size;
     324         540 :         s->m.first_slice_line = 1;
     325        4545 :         for (y = 0; y < block_height; y++) {
     326        4005 :             s->m.new_picture.f->data[0] = src - y * 16 * stride; // ugly
     327        4005 :             s->m.mb_y                  = y;
     328             : 
     329       64575 :             for (i = 0; i < 16 && i + 16 * y < height; i++) {
     330       60570 :                 memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
     331             :                        width);
     332      243270 :                 for (x = width; x < 16 * block_width; x++)
     333      182700 :                     src[i * stride + x] = src[i * stride + x - 1];
     334             :             }
     335        7515 :             for (; i < 16 && i + 16 * y < 16 * block_height; i++)
     336        3510 :                 memcpy(&src[i * stride], &src[(i - 1) * stride],
     337        3510 :                        16 * block_width);
     338             : 
     339       66060 :             for (x = 0; x < block_width; x++) {
     340       62055 :                 s->m.mb_x = x;
     341       62055 :                 init_block_index(&s->m);
     342             : 
     343       62055 :                 ff_estimate_p_frame_motion(&s->m, x, y);
     344             :             }
     345        4005 :             s->m.first_slice_line = 0;
     346             :         }
     347             : 
     348         540 :         ff_fix_long_p_mvs(&s->m);
     349         540 :         ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,
     350             :                         CANDIDATE_MB_TYPE_INTER, 0);
     351             :     }
     352             : 
     353         600 :     s->m.first_slice_line = 1;
     354        5050 :     for (y = 0; y < block_height; y++) {
     355       71750 :         for (i = 0; i < 16 && i + 16 * y < height; i++) {
     356       67300 :             memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
     357             :                    width);
     358      270300 :             for (x = width; x < 16 * block_width; x++)
     359      203000 :                 src[i * stride + x] = src[i * stride + x - 1];
     360             :         }
     361        8350 :         for (; i < 16 && i + 16 * y < 16 * block_height; i++)
     362        3900 :             memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);
     363             : 
     364        4450 :         s->m.mb_y = y;
     365       73400 :         for (x = 0; x < block_width; x++) {
     366             :             uint8_t reorder_buffer[2][6][7 * 32];
     367             :             int count[2][6];
     368       68950 :             int offset       = y * 16 * stride + x * 16;
     369       68950 :             uint8_t *decoded = decoded_plane + offset;
     370       68950 :             uint8_t *ref     = ref_plane + offset;
     371       68950 :             int score[4]     = { 0, 0, 0, 0 }, best;
     372       68950 :             uint8_t *temp    = s->scratchbuf;
     373             : 
     374      137900 :             if (s->pb.buf_end - s->pb.buf -
     375       68950 :                 (put_bits_count(&s->pb) >> 3) < 3000) { // FIXME: check size
     376           0 :                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
     377           0 :                 return -1;
     378             :             }
     379             : 
     380       68950 :             s->m.mb_x = x;
     381       68950 :             init_block_index(&s->m);
     382             : 
     383      141354 :             if (s->pict_type == AV_PICTURE_TYPE_I ||
     384       62055 :                 (s->m.mb_type[x + y * s->m.mb_stride] &
     385             :                  CANDIDATE_MB_TYPE_INTRA)) {
     386       72443 :                 for (i = 0; i < 6; i++)
     387       62094 :                     init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
     388             :                                   7 * 32);
     389       10349 :                 if (s->pict_type == AV_PICTURE_TYPE_P) {
     390        3454 :                     const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
     391        3454 :                     put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
     392        3454 :                     score[0] = vlc[1] * lambda;
     393             :                 }
     394       10349 :                 score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,
     395             :                                          5, 64, lambda, 1);
     396       72443 :                 for (i = 0; i < 6; i++) {
     397       62094 :                     count[0][i] = put_bits_count(&s->reorder_pb[i]);
     398       62094 :                     flush_put_bits(&s->reorder_pb[i]);
     399             :                 }
     400             :             } else
     401       58601 :                 score[0] = INT_MAX;
     402             : 
     403       68950 :             best = 0;
     404             : 
     405       68950 :             if (s->pict_type == AV_PICTURE_TYPE_P) {
     406       62055 :                 const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];
     407             :                 int mx, my, pred_x, pred_y, dxy;
     408             :                 int16_t *motion_ptr;
     409             : 
     410       62055 :                 motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
     411       62055 :                 if (s->m.mb_type[x + y * s->m.mb_stride] &
     412             :                     CANDIDATE_MB_TYPE_INTER) {
     413      410207 :                     for (i = 0; i < 6; i++)
     414      351606 :                         init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
     415             :                                       7 * 32);
     416             : 
     417       58601 :                     put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
     418             : 
     419       58601 :                     s->m.pb = s->reorder_pb[5];
     420       58601 :                     mx      = motion_ptr[0];
     421       58601 :                     my      = motion_ptr[1];
     422             :                     av_assert1(mx     >= -32 && mx     <= 31);
     423             :                     av_assert1(my     >= -32 && my     <= 31);
     424             :                     av_assert1(pred_x >= -32 && pred_x <= 31);
     425             :                     av_assert1(pred_y >= -32 && pred_y <= 31);
     426       58601 :                     ff_h263_encode_motion(&s->m.pb, mx - pred_x, 1);
     427       58601 :                     ff_h263_encode_motion(&s->m.pb, my - pred_y, 1);
     428       58601 :                     s->reorder_pb[5] = s->m.pb;
     429       58601 :                     score[1]        += lambda * put_bits_count(&s->reorder_pb[5]);
     430             : 
     431       58601 :                     dxy = (mx & 1) + 2 * (my & 1);
     432             : 
     433      117202 :                     s->hdsp.put_pixels_tab[0][dxy](temp + 16*stride,
     434      117202 :                                                    ref + (mx >> 1) +
     435       58601 :                                                    stride * (my >> 1),
     436             :                                                    stride, 16);
     437             : 
     438       58601 :                     score[1] += encode_block(s, src + 16 * x, temp + 16*stride,
     439             :                                              decoded, stride, 5, 64, lambda, 0);
     440       58601 :                     best      = score[1] <= score[0];
     441             : 
     442       58601 :                     vlc       = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
     443       58601 :                     score[2]  = s->mecc.sse[0](NULL, src + 16 * x, ref,
     444             :                                                stride, 16);
     445       58601 :                     score[2] += vlc[1] * lambda;
     446       58601 :                     if (score[2] < score[best] && mx == 0 && my == 0) {
     447          84 :                         best = 2;
     448          84 :                         s->hdsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
     449          84 :                         put_bits(&s->pb, vlc[1], vlc[0]);
     450             :                     }
     451             :                 }
     452             : 
     453       62055 :                 if (best == 1) {
     454      409619 :                     for (i = 0; i < 6; i++) {
     455      351102 :                         count[1][i] = put_bits_count(&s->reorder_pb[i]);
     456      351102 :                         flush_put_bits(&s->reorder_pb[i]);
     457             :                     }
     458             :                 } else {
     459        3538 :                     motion_ptr[0]                      =
     460        7076 :                     motion_ptr[1]                      =
     461       10614 :                     motion_ptr[2]                      =
     462       10614 :                     motion_ptr[3]                      =
     463       10614 :                     motion_ptr[0 + 2 * s->m.b8_stride] =
     464       10614 :                     motion_ptr[1 + 2 * s->m.b8_stride] =
     465       10614 :                     motion_ptr[2 + 2 * s->m.b8_stride] =
     466        7076 :                     motion_ptr[3 + 2 * s->m.b8_stride] = 0;
     467             :                 }
     468             :             }
     469             : 
     470       68950 :             s->rd_total += score[best];
     471             : 
     472       68950 :             if (best != 2)
     473      482062 :             for (i = 5; i >= 0; i--)
     474      413196 :                 avpriv_copy_bits(&s->pb, reorder_buffer[best][i],
     475             :                                  count[best][i]);
     476       68950 :             if (best == 0)
     477       10349 :                 s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
     478             :         }
     479        4450 :         s->m.first_slice_line = 0;
     480             :     }
     481         600 :     return 0;
     482             : }
     483             : 
     484           4 : static av_cold int svq1_encode_end(AVCodecContext *avctx)
     485             : {
     486           4 :     SVQ1EncContext *const s = avctx->priv_data;
     487             :     int i;
     488             : 
     489           8 :     av_log(avctx, AV_LOG_DEBUG, "RD: %f\n",
     490          12 :            s->rd_total / (double)(avctx->width * avctx->height *
     491           4 :                                   avctx->frame_number));
     492             : 
     493           4 :     s->m.mb_type = NULL;
     494           4 :     ff_mpv_common_end(&s->m);
     495             : 
     496           4 :     av_freep(&s->m.me.scratchpad);
     497           4 :     av_freep(&s->m.me.map);
     498           4 :     av_freep(&s->m.me.score_map);
     499           4 :     av_freep(&s->mb_type);
     500           4 :     av_freep(&s->dummy);
     501           4 :     av_freep(&s->scratchbuf);
     502             : 
     503          16 :     for (i = 0; i < 3; i++) {
     504          12 :         av_freep(&s->motion_val8[i]);
     505          12 :         av_freep(&s->motion_val16[i]);
     506             :     }
     507             : 
     508           4 :     av_frame_free(&s->current_picture);
     509           4 :     av_frame_free(&s->last_picture);
     510             : 
     511           4 :     return 0;
     512             : }
     513             : 
     514           4 : static av_cold int svq1_encode_init(AVCodecContext *avctx)
     515             : {
     516           4 :     SVQ1EncContext *const s = avctx->priv_data;
     517             :     int ret;
     518             : 
     519           4 :     if (avctx->width >= 4096 || avctx->height >= 4096) {
     520           0 :         av_log(avctx, AV_LOG_ERROR, "Dimensions too large, maximum is 4095x4095\n");
     521           0 :         return AVERROR(EINVAL);
     522             :     }
     523             : 
     524           4 :     ff_hpeldsp_init(&s->hdsp, avctx->flags);
     525           4 :     ff_me_cmp_init(&s->mecc, avctx);
     526           4 :     ff_mpegvideoencdsp_init(&s->m.mpvencdsp, avctx);
     527             : 
     528           4 :     s->current_picture = av_frame_alloc();
     529           4 :     s->last_picture    = av_frame_alloc();
     530           4 :     if (!s->current_picture || !s->last_picture) {
     531           0 :         svq1_encode_end(avctx);
     532           0 :         return AVERROR(ENOMEM);
     533             :     }
     534             : 
     535           4 :     s->frame_width  = avctx->width;
     536           4 :     s->frame_height = avctx->height;
     537             : 
     538           4 :     s->y_block_width  = (s->frame_width  + 15) / 16;
     539           4 :     s->y_block_height = (s->frame_height + 15) / 16;
     540             : 
     541           4 :     s->c_block_width  = (s->frame_width  / 4 + 15) / 16;
     542           4 :     s->c_block_height = (s->frame_height / 4 + 15) / 16;
     543             : 
     544           4 :     s->avctx               = avctx;
     545           4 :     s->m.avctx             = avctx;
     546             : 
     547           4 :     if ((ret = ff_mpv_common_init(&s->m)) < 0) {
     548           0 :         svq1_encode_end(avctx);
     549           0 :         return ret;
     550             :     }
     551             : 
     552           4 :     s->m.picture_structure = PICT_FRAME;
     553           4 :     s->m.me.temp           =
     554           8 :     s->m.me.scratchpad     = av_mallocz((avctx->width + 64) *
     555           4 :                                         2 * 16 * 2 * sizeof(uint8_t));
     556           4 :     s->m.me.map            = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
     557           4 :     s->m.me.score_map      = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
     558           8 :     s->mb_type             = av_mallocz((s->y_block_width + 1) *
     559           4 :                                         s->y_block_height * sizeof(int16_t));
     560           8 :     s->dummy               = av_mallocz((s->y_block_width + 1) *
     561           4 :                                         s->y_block_height * sizeof(int32_t));
     562           4 :     s->ssd_int8_vs_int16   = ssd_int8_vs_int16_c;
     563             : 
     564           8 :     if (!s->m.me.temp || !s->m.me.scratchpad || !s->m.me.map ||
     565           8 :         !s->m.me.score_map || !s->mb_type || !s->dummy) {
     566           0 :         svq1_encode_end(avctx);
     567           0 :         return AVERROR(ENOMEM);
     568             :     }
     569             : 
     570             :     if (ARCH_PPC)
     571             :         ff_svq1enc_init_ppc(s);
     572             :     if (ARCH_X86)
     573           4 :         ff_svq1enc_init_x86(s);
     574             : 
     575           4 :     ff_h263_encode_init(&s->m); // mv_penalty
     576             : 
     577           4 :     return 0;
     578             : }
     579             : 
     580         200 : static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     581             :                              const AVFrame *pict, int *got_packet)
     582             : {
     583         200 :     SVQ1EncContext *const s = avctx->priv_data;
     584             :     int i, ret;
     585             : 
     586         400 :     if ((ret = ff_alloc_packet2(avctx, pkt, s->y_block_width * s->y_block_height *
     587         200 :                              MAX_MB_BYTES*3 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
     588           0 :         return ret;
     589             : 
     590         200 :     if (avctx->pix_fmt != AV_PIX_FMT_YUV410P) {
     591           0 :         av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
     592           0 :         return -1;
     593             :     }
     594             : 
     595         200 :     if (!s->current_picture->data[0]) {
     596           4 :         if ((ret = ff_get_buffer(avctx, s->current_picture, 0)) < 0) {
     597           0 :             return ret;
     598             :         }
     599             :     }
     600         200 :     if (!s->last_picture->data[0]) {
     601           4 :         ret = ff_get_buffer(avctx, s->last_picture, 0);
     602           4 :         if (ret < 0)
     603           0 :             return ret;
     604             :     }
     605         200 :     if (!s->scratchbuf) {
     606           4 :         s->scratchbuf = av_malloc_array(s->current_picture->linesize[0], 16 * 3);
     607           4 :         if (!s->scratchbuf)
     608           0 :             return AVERROR(ENOMEM);
     609             :     }
     610             : 
     611         200 :     FFSWAP(AVFrame*, s->current_picture, s->last_picture);
     612             : 
     613         200 :     init_put_bits(&s->pb, pkt->data, pkt->size);
     614             : 
     615         200 :     if (avctx->gop_size && (avctx->frame_number % avctx->gop_size))
     616         180 :         s->pict_type = AV_PICTURE_TYPE_P;
     617             :     else
     618          20 :         s->pict_type = AV_PICTURE_TYPE_I;
     619         200 :     s->quality = pict->quality;
     620             : 
     621             : #if FF_API_CODED_FRAME
     622             : FF_DISABLE_DEPRECATION_WARNINGS
     623         200 :     avctx->coded_frame->pict_type = s->pict_type;
     624         200 :     avctx->coded_frame->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
     625             : FF_ENABLE_DEPRECATION_WARNINGS
     626             : #endif
     627             : 
     628         200 :     ff_side_data_set_encoder_stats(pkt, pict->quality, NULL, 0, s->pict_type);
     629             : 
     630         200 :     svq1_write_header(s, s->pict_type);
     631         800 :     for (i = 0; i < 3; i++) {
     632        2400 :         int ret = svq1_encode_plane(s, i,
     633         600 :                               pict->data[i],
     634         600 :                               s->last_picture->data[i],
     635         600 :                               s->current_picture->data[i],
     636         600 :                               s->frame_width  / (i ? 4 : 1),
     637         600 :                               s->frame_height / (i ? 4 : 1),
     638             :                               pict->linesize[i],
     639         600 :                               s->current_picture->linesize[i]);
     640         600 :         emms_c();
     641         600 :         if (ret < 0) {
     642             :             int j;
     643           0 :             for (j = 0; j < i; j++) {
     644           0 :                 av_freep(&s->motion_val8[j]);
     645           0 :                 av_freep(&s->motion_val16[j]);
     646             :             }
     647           0 :             av_freep(&s->scratchbuf);
     648           0 :             return -1;
     649             :         }
     650             :     }
     651             : 
     652             :     // avpriv_align_put_bits(&s->pb);
     653        3565 :     while (put_bits_count(&s->pb) & 31)
     654        3165 :         put_bits(&s->pb, 1, 0);
     655             : 
     656         200 :     flush_put_bits(&s->pb);
     657             : 
     658         200 :     pkt->size = put_bits_count(&s->pb) / 8;
     659         200 :     if (s->pict_type == AV_PICTURE_TYPE_I)
     660          20 :         pkt->flags |= AV_PKT_FLAG_KEY;
     661         200 :     *got_packet = 1;
     662             : 
     663         200 :     return 0;
     664             : }
     665             : 
     666             : #define OFFSET(x) offsetof(struct SVQ1EncContext, x)
     667             : #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
     668             : static const AVOption options[] = {
     669             :     { "motion-est", "Motion estimation algorithm", OFFSET(motion_est), AV_OPT_TYPE_INT, { .i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, VE, "motion-est"},
     670             :         { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
     671             :         { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
     672             :         { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion-est" },
     673             : 
     674             :     { NULL },
     675             : };
     676             : 
     677             : static const AVClass svq1enc_class = {
     678             :     .class_name = "svq1enc",
     679             :     .item_name  = av_default_item_name,
     680             :     .option     = options,
     681             :     .version    = LIBAVUTIL_VERSION_INT,
     682             : };
     683             : 
     684             : AVCodec ff_svq1_encoder = {
     685             :     .name           = "svq1",
     686             :     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
     687             :     .type           = AVMEDIA_TYPE_VIDEO,
     688             :     .id             = AV_CODEC_ID_SVQ1,
     689             :     .priv_data_size = sizeof(SVQ1EncContext),
     690             :     .priv_class     = &svq1enc_class,
     691             :     .init           = svq1_encode_init,
     692             :     .encode2        = svq1_encode_frame,
     693             :     .close          = svq1_encode_end,
     694             :     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
     695             :                                                      AV_PIX_FMT_NONE },
     696             : };

Generated by: LCOV version 1.13