中缅合建天然气电厂竣工助缅供电 - 中房镇新闻网

Directory:	../../../ffmpeg/
File:	src/libavcodec/wmv2enc.c
Date:	2025-08-04 00:43:16

	Exec	Total	Coverage
Lines:	118	124	95.2%
Functions:	4	4	100.0%
Branches:	34	48	70.8%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2002 The FFmpeg Project
    
       *
    
       * 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
    
       */
    
      #include "libavutil/mem.h"
    
      #include "avcodec.h"
    
      #include "codec_internal.h"
    
      #include "h263.h"
    
      #include "mpegvideo.h"
    
      #include "mpegvideoenc.h"
    
      #include "msmpeg4.h"
    
      #include "msmpeg4enc.h"
    
      #include "msmpeg4data.h"
    
      #include "msmpeg4_vc1_data.h"
    
      #include "put_bits.h"
    
      #include "wmv2.h"
    
      #define WMV2_EXTRADATA_SIZE 4
    
      typedef struct WMV2EncContext {
    
          MSMPEG4EncContext msmpeg4;
    
          WMV2Context common;
    
          int j_type_bit;
    
          int j_type;
    
          int abt_flag;
    
          int abt_type;
    
          int per_mb_abt;
    
          int mspel_bit;
    
          int cbp_table_index;
    
          int top_left_mv_flag;
    
          int per_mb_rl_bit;
    
      } WMV2EncContext;
    
      4
      static int encode_ext_header(WMV2EncContext *w)
    
      {
    
      4
          MPVEncContext *const s = &w->msmpeg4.m.s;
    
          PutBitContext pb;
    
          int code;
    
      4
          init_put_bits(&pb, s->c.avctx->extradata, WMV2_EXTRADATA_SIZE);
    
      4
          put_bits(&pb, 5, s->c.avctx->time_base.den / s->c.avctx->time_base.num); // yes 29.97 -> 29
    
        1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.

      4
          put_bits(&pb, 11, FFMIN(w->msmpeg4.m.bit_rate / 1024, 2047));
    
      4
          put_bits(&pb, 1, w->mspel_bit        = 1);
    
      4
          put_bits(&pb, 1, s->loop_filter);
    
      4
          put_bits(&pb, 1, w->abt_flag         = 1);
    
      4
          put_bits(&pb, 1, w->j_type_bit       = 1);
    
      4
          put_bits(&pb, 1, w->top_left_mv_flag = 0);
    
      4
          put_bits(&pb, 1, w->per_mb_rl_bit    = 1);
    
      4
          put_bits(&pb, 3, code                = 1);
    
      4
          flush_put_bits(&pb);
    
      4
          s->slice_height = s->c.mb_height / code;
    
      4
          return 0;
    
      }
    
      200
      static int wmv2_encode_picture_header(MPVMainEncContext *const m)
    
      {
    
      200
          WMV2EncContext *const w = (WMV2EncContext *) m;
    
      200
          MSMPEG4EncContext *const ms = &w->msmpeg4;
    
      200
          MPVEncContext *const s = &m->s;
    
      200
          put_bits_assume_flushed(&s->pb);
    
      200
          put_bits(&s->pb, 1, s->c.pict_type - 1);
    
        2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 180 times.

      200
          if (s->c.pict_type == AV_PICTURE_TYPE_I)
    
      20
              put_bits(&s->pb, 7, 0);
    
      200
          put_bits(&s->pb, 5, s->c.qscale);
    
      200
          ms->dc_table_index  = 1;
    
      200
          ms->mv_table_index  = 1; /* only if P-frame */
    
      200
          ms->per_mb_rl_table = 0;
    
      200
          s->c.mspel          = 0;
    
      200
          w->per_mb_abt      = 0;
    
      200
          w->abt_type        = 0;
    
      200
          w->j_type          = 0;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.

      200
          av_assert0(s->flipflop_rounding);
    
        2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 180 times.

      200
          if (s->c.pict_type == AV_PICTURE_TYPE_I) {
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20 times.

      20
              av_assert0(s->c.no_rounding == 1);
    
        1/2✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.

      20
              if (w->j_type_bit)
    
      20
                  put_bits(&s->pb, 1, w->j_type);
    
        1/2✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.

      20
              if (w->per_mb_rl_bit)
    
      20
                  put_bits(&s->pb, 1, ms->per_mb_rl_table);
    
        1/2✓ Branch 0 taken 20 times.
✗ Branch 1 not taken.

      20
              if (!ms->per_mb_rl_table) {
    
      20
                  ff_msmpeg4_code012(&s->pb, ms->rl_chroma_table_index);
    
      20
                  ff_msmpeg4_code012(&s->pb, ms->rl_table_index);
    
              }
    
      20
              put_bits(&s->pb, 1, ms->dc_table_index);
    
      20
              s->c.inter_intra_pred = 0;
    
          } else {
    
              int cbp_index;
    
      180
              put_bits(&s->pb, 2, SKIP_TYPE_NONE);
    
      180
              ff_msmpeg4_code012(&s->pb, cbp_index = 0);
    
      180
              w->cbp_table_index = wmv2_get_cbp_table_index(s->c.qscale, cbp_index);
    
        1/2✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.

      180
              if (w->mspel_bit)
    
      180
                  put_bits(&s->pb, 1, s->c.mspel);
    
        1/2✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.

      180
              if (w->abt_flag) {
    
      180
                  put_bits(&s->pb, 1, w->per_mb_abt ^ 1);
    
        1/2✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.

      180
                  if (!w->per_mb_abt)
    
      180
                      ff_msmpeg4_code012(&s->pb, w->abt_type);
    
              }
    
        1/2✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.

      180
              if (w->per_mb_rl_bit)
    
      180
                  put_bits(&s->pb, 1, ms->per_mb_rl_table);
    
        1/2✓ Branch 0 taken 180 times.
✗ Branch 1 not taken.

      180
              if (!ms->per_mb_rl_table) {
    
      180
                  ff_msmpeg4_code012(&s->pb, ms->rl_table_index);
    
      180
                  ms->rl_chroma_table_index = ms->rl_table_index;
    
              }
    
      180
              put_bits(&s->pb, 1, ms->dc_table_index);
    
      180
              put_bits(&s->pb, 1, ms->mv_table_index);
    
      180
              s->c.inter_intra_pred = 0; // (s->c.width * s->c.height < 320 * 240 && m->bit_rate <= II_BITRATE);
    
          }
    
      200
          s->esc3_level_length = 0;
    
      200
          ms->esc3_run_length  = 0;
    
      200
          return 0;
    
      }
    
      /* Nearly identical to wmv1 but that is just because we do not use the
    
       * useless M$ crap features. It is duplicated here in case someone wants
    
       * to add support for these crap features. */
    
      59850
      static void wmv2_encode_mb(MPVEncContext *const s, int16_t block[][64],
    
                                 int motion_x, int motion_y)
    
      {
    
      59850
          WMV2EncContext *const w = (WMV2EncContext *) s;
    
          int cbp, coded_cbp, i;
    
          int pred_x, pred_y;
    
          uint8_t *coded_block;
    
      59850
          ff_msmpeg4_handle_slices(s);
    
        2/2✓ Branch 0 taken 51711 times.
✓ Branch 1 taken 8139 times.

      59850
          if (!s->c.mb_intra) {
    
              /* compute cbp */
    
      51711
              cbp = 0;
    
        2/2✓ Branch 0 taken 310266 times.
✓ Branch 1 taken 51711 times.

      361977
              for (i = 0; i < 6; i++)
    
        2/2✓ Branch 0 taken 109321 times.
✓ Branch 1 taken 200945 times.

      310266
                  if (s->c.block_last_index[i] >= 0)
    
      109321
                      cbp |= 1 << (5 - i);
    
      51711
              put_bits(&s->pb,
    
      51711
                       ff_wmv2_inter_table[w->cbp_table_index][cbp + 64][1],
    
      51711
                       ff_wmv2_inter_table[w->cbp_table_index][cbp + 64][0]);
    
      51711
              s->misc_bits += get_bits_diff(s);
    
              /* motion vector */
    
      51711
              ff_h263_pred_motion(&s->c, 0, 0, &pred_x, &pred_y);
    
      51711
              ff_msmpeg4_encode_motion(&w->msmpeg4, motion_x - pred_x,
    
                                       motion_y - pred_y);
    
      51711
              s->mv_bits += get_bits_diff(s);
    
          } else {
    
              /* compute cbp */
    
      8139
              cbp       = 0;
    
      8139
              coded_cbp = 0;
    
        2/2✓ Branch 0 taken 48834 times.
✓ Branch 1 taken 8139 times.

      56973
              for (i = 0; i < 6; i++) {
    
      48834
                  int val = (s->c.block_last_index[i] >= 1);
    
      48834
                  cbp |= val << (5 - i);
    
        2/2✓ Branch 0 taken 32556 times.
✓ Branch 1 taken 16278 times.

      48834
                  if (i < 4) {
    
                      /* predict value for close blocks only for luma */
    
      32556
                      int pred     = ff_msmpeg4_coded_block_pred(&s->c, i, &coded_block);
    
      32556
                      *coded_block = val;
    
      32556
                      val          = val ^ pred;
    
                  }
    
      48834
                  coded_cbp |= val << (5 - i);
    
              }
    
        2/2✓ Branch 0 taken 5985 times.
✓ Branch 1 taken 2154 times.

      8139
              if (s->c.pict_type == AV_PICTURE_TYPE_I)
    
      5985
                  put_bits(&s->pb,
    
      5985
                           ff_msmp4_mb_i_table[coded_cbp][1],
    
      5985
                           ff_msmp4_mb_i_table[coded_cbp][0]);
    
              else
    
      2154
                  put_bits(&s->pb,
    
      2154
                           ff_wmv2_inter_table[w->cbp_table_index][cbp][1],
    
      2154
                           ff_wmv2_inter_table[w->cbp_table_index][cbp][0]);
    
      8139
              put_bits(&s->pb, 1, 0);         /* no AC prediction yet */
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8139 times.

      8139
              if (s->c.inter_intra_pred) {
    
      ✗
                  s->c.h263_aic_dir = 0;
    
      ✗
                  put_bits(&s->pb,
    
      ✗
                           ff_table_inter_intra[s->c.h263_aic_dir][1],
    
      ✗
                           ff_table_inter_intra[s->c.h263_aic_dir][0]);
    
              }
    
      8139
              s->misc_bits += get_bits_diff(s);
    
          }
    
        2/2✓ Branch 0 taken 359100 times.
✓ Branch 1 taken 59850 times.

      418950
          for (i = 0; i < 6; i++)
    
      359100
              ff_msmpeg4_encode_block(s, block[i], i);
    
        2/2✓ Branch 0 taken 8139 times.
✓ Branch 1 taken 51711 times.

      59850
          if (s->c.mb_intra)
    
      8139
              s->i_tex_bits += get_bits_diff(s);
    
          else
    
      51711
              s->p_tex_bits += get_bits_diff(s);
    
      59850
      }
    
      4
      static av_cold int wmv2_encode_init(AVCodecContext *avctx)
    
      {
    
      4
          WMV2EncContext *const w = avctx->priv_data;
    
      4
          MPVEncContext *const s = &w->msmpeg4.m.s;
    
          int ret;
    
      4
          w->msmpeg4.m.encode_picture_header = wmv2_encode_picture_header;
    
      4
          s->encode_mb                       = wmv2_encode_mb;
    
      4
          s->c.private_ctx = &w->common;
    
      4
          ret = ff_mpv_encode_init(avctx);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

      4
          if (ret < 0)
    
      ✗
              return ret;
    
      4
          ff_wmv2_common_init(&s->c);
    
      4
          avctx->extradata_size = WMV2_EXTRADATA_SIZE;
    
      4
          avctx->extradata      = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

      4
          if (!avctx->extradata)
    
      ✗
              return AVERROR(ENOMEM);
    
      4
          encode_ext_header(w);
    
      4
          return 0;
    
      }
    
      const FFCodec ff_wmv2_encoder = {
    
          .p.name         = "wmv2",
    
          CODEC_LONG_NAME("Windows Media Video 8"),
    
          .p.type         = AVMEDIA_TYPE_VIDEO,
    
          .p.id           = AV_CODEC_ID_WMV2,
    
          .p.priv_class   = &ff_mpv_enc_class,
    
          .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
    
          .priv_data_size = sizeof(WMV2EncContext),
    
          .init           = wmv2_encode_init,
    
          FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
    
          .close          = ff_mpv_encode_end,
    
          .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
    
          .color_ranges   = AVCOL_RANGE_MPEG,
    
          CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
    
      };

惹上官司是犯了什么煞	女人为什么不会怀孕	vdr是什么意思	巨蟹是什么星座	乐不思蜀是什么意思
彪悍是什么意思	cho是什么意思	瑞舒伐他汀钙片治什么病	什么是牛黄	胃肠感冒吃什么食物比较好
什么是龋齿	什么饮料解暑	你说什么	梦见狐狸是什么预兆	非分之想是什么意思
受精卵着床有什么反应	枸杞加什么泡水喝壮阳	地主之谊是什么意思	什么样的刘胡兰	一直很困想睡觉是什么原因

大姨妈推迟什么原因hcv8jop5ns2r.cn	4月16日什么星座hcv9jop7ns5r.cn	五行中什么生木hcv9jop3ns9r.cn	肛门里面痒是什么情况hcv7jop9ns7r.cn	晓五行属性是什么hcv7jop4ns7r.cn
手臂酸痛什么原因hcv8jop7ns9r.cn	心里发慌是什么病hcv9jop4ns9r.cn	什么什么之财hcv8jop1ns4r.cn	鼻塞黄鼻涕吃什么药hcv9jop4ns6r.cn	孕妇能喝什么饮料hcv8jop1ns1r.cn
心跳加快是什么病hcv8jop0ns9r.cn	喉咙疼挂什么科hcv8jop0ns4r.cn	江西有什么景点hcv8jop0ns7r.cn	剑走偏锋是什么意思hcv8jop6ns0r.cn	哺乳期可以喝什么饮料hcv8jop6ns2r.cn
智商130算什么水平hcv8jop0ns0r.cn	过期红酒有什么用途hcv9jop0ns1r.cn	自言自语是什么hcv8jop5ns3r.cn	马革裹尸是什么意思hcv9jop6ns4r.cn	妇科炎症吃什么药hcv8jop9ns5r.cn

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2002 The FFmpeg Project
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			#include "libavutil/mem.h"
22			#include "avcodec.h"
23			#include "codec_internal.h"
24			#include "h263.h"
25			#include "mpegvideo.h"
26			#include "mpegvideoenc.h"
27			#include "msmpeg4.h"
28			#include "msmpeg4enc.h"
29			#include "msmpeg4data.h"
30			#include "msmpeg4_vc1_data.h"
31			#include "put_bits.h"
32			#include "wmv2.h"
33
34			#define WMV2_EXTRADATA_SIZE 4
35
36			typedef struct WMV2EncContext {
37			MSMPEG4EncContext msmpeg4;
38			WMV2Context common;
39			int j_type_bit;
40			int j_type;
41			int abt_flag;
42			int abt_type;
43			int per_mb_abt;
44			int mspel_bit;
45			int cbp_table_index;
46			int top_left_mv_flag;
47			int per_mb_rl_bit;
48			} WMV2EncContext;
49
50		4	static int encode_ext_header(WMV2EncContext *w)
51			{
52		4	MPVEncContext *const s = &w->msmpeg4.m.s;
53			PutBitContext pb;
54			int code;
55
56		4	init_put_bits(&pb, s->c.avctx->extradata, WMV2_EXTRADATA_SIZE);
57
58		4	put_bits(&pb, 5, s->c.avctx->time_base.den / s->c.avctx->time_base.num); // yes 29.97 -> 29
59	1/2 ✓ Branch 0 taken 4 times. ✗ Branch 1 not taken.	4	put_bits(&pb, 11, FFMIN(w->msmpeg4.m.bit_rate / 1024, 2047));
60
61		4	put_bits(&pb, 1, w->mspel_bit = 1);
62		4	put_bits(&pb, 1, s->loop_filter);
63		4	put_bits(&pb, 1, w->abt_flag = 1);
64		4	put_bits(&pb, 1, w->j_type_bit = 1);
65		4	put_bits(&pb, 1, w->top_left_mv_flag = 0);
66		4	put_bits(&pb, 1, w->per_mb_rl_bit = 1);
67		4	put_bits(&pb, 3, code = 1);
68
69		4	flush_put_bits(&pb);
70
71		4	s->slice_height = s->c.mb_height / code;
72
73		4	return 0;
74			}
75
76		200	static int wmv2_encode_picture_header(MPVMainEncContext *const m)
77			{
78		200	WMV2EncContext const w = (WMV2EncContext ) m;
79		200	MSMPEG4EncContext *const ms = &w->msmpeg4;
80		200	MPVEncContext *const s = &m->s;
81
82		200	put_bits_assume_flushed(&s->pb);
83
84		200	put_bits(&s->pb, 1, s->c.pict_type - 1);
85	2/2 ✓ Branch 0 taken 20 times. ✓ Branch 1 taken 180 times.	200	if (s->c.pict_type == AV_PICTURE_TYPE_I)
86		20	put_bits(&s->pb, 7, 0);
87		200	put_bits(&s->pb, 5, s->c.qscale);
88
89		200	ms->dc_table_index = 1;
90		200	ms->mv_table_index = 1; /* only if P-frame */
91		200	ms->per_mb_rl_table = 0;
92		200	s->c.mspel = 0;
93		200	w->per_mb_abt = 0;
94		200	w->abt_type = 0;
95		200	w->j_type = 0;
96
97	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 200 times.	200	av_assert0(s->flipflop_rounding);
98
99	2/2 ✓ Branch 0 taken 20 times. ✓ Branch 1 taken 180 times.	200	if (s->c.pict_type == AV_PICTURE_TYPE_I) {
100	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 20 times.	20	av_assert0(s->c.no_rounding == 1);
101	1/2 ✓ Branch 0 taken 20 times. ✗ Branch 1 not taken.	20	if (w->j_type_bit)
102		20	put_bits(&s->pb, 1, w->j_type);
103
104	1/2 ✓ Branch 0 taken 20 times. ✗ Branch 1 not taken.	20	if (w->per_mb_rl_bit)
105		20	put_bits(&s->pb, 1, ms->per_mb_rl_table);
106
107	1/2 ✓ Branch 0 taken 20 times. ✗ Branch 1 not taken.	20	if (!ms->per_mb_rl_table) {
108		20	ff_msmpeg4_code012(&s->pb, ms->rl_chroma_table_index);
109		20	ff_msmpeg4_code012(&s->pb, ms->rl_table_index);
110			}
111
112		20	put_bits(&s->pb, 1, ms->dc_table_index);
113
114		20	s->c.inter_intra_pred = 0;
115			} else {
116			int cbp_index;
117
118		180	put_bits(&s->pb, 2, SKIP_TYPE_NONE);
119
120		180	ff_msmpeg4_code012(&s->pb, cbp_index = 0);
121		180	w->cbp_table_index = wmv2_get_cbp_table_index(s->c.qscale, cbp_index);
122
123	1/2 ✓ Branch 0 taken 180 times. ✗ Branch 1 not taken.	180	if (w->mspel_bit)
124		180	put_bits(&s->pb, 1, s->c.mspel);
125
126	1/2 ✓ Branch 0 taken 180 times. ✗ Branch 1 not taken.	180	if (w->abt_flag) {
127		180	put_bits(&s->pb, 1, w->per_mb_abt ^ 1);
128	1/2 ✓ Branch 0 taken 180 times. ✗ Branch 1 not taken.	180	if (!w->per_mb_abt)
129		180	ff_msmpeg4_code012(&s->pb, w->abt_type);
130			}
131
132	1/2 ✓ Branch 0 taken 180 times. ✗ Branch 1 not taken.	180	if (w->per_mb_rl_bit)
133		180	put_bits(&s->pb, 1, ms->per_mb_rl_table);
134
135	1/2 ✓ Branch 0 taken 180 times. ✗ Branch 1 not taken.	180	if (!ms->per_mb_rl_table) {
136		180	ff_msmpeg4_code012(&s->pb, ms->rl_table_index);
137		180	ms->rl_chroma_table_index = ms->rl_table_index;
138			}
139		180	put_bits(&s->pb, 1, ms->dc_table_index);
140		180	put_bits(&s->pb, 1, ms->mv_table_index);
141
142		180	s->c.inter_intra_pred = 0; // (s->c.width * s->c.height < 320 * 240 && m->bit_rate <= II_BITRATE);
143			}
144		200	s->esc3_level_length = 0;
145		200	ms->esc3_run_length = 0;
146
147		200	return 0;
148			}
149
150			/* Nearly identical to wmv1 but that is just because we do not use the
151			* useless M$ crap features. It is duplicated here in case someone wants
152			* to add support for these crap features. */
153		59850	static void wmv2_encode_mb(MPVEncContext *const s, int16_t block[][64],
154			int motion_x, int motion_y)
155			{
156		59850	WMV2EncContext const w = (WMV2EncContext ) s;
157			int cbp, coded_cbp, i;
158			int pred_x, pred_y;
159			uint8_t *coded_block;
160
161		59850	ff_msmpeg4_handle_slices(s);
162
163	2/2 ✓ Branch 0 taken 51711 times. ✓ Branch 1 taken 8139 times.	59850	if (!s->c.mb_intra) {
164			/* compute cbp */
165		51711	cbp = 0;
166	2/2 ✓ Branch 0 taken 310266 times. ✓ Branch 1 taken 51711 times.	361977	for (i = 0; i < 6; i++)
167	2/2 ✓ Branch 0 taken 109321 times. ✓ Branch 1 taken 200945 times.	310266	if (s->c.block_last_index[i] >= 0)
168		109321	cbp \|= 1 << (5 - i);
169
170		51711	put_bits(&s->pb,
171		51711	ff_wmv2_inter_table[w->cbp_table_index][cbp + 64][1],
172		51711	ff_wmv2_inter_table[w->cbp_table_index][cbp + 64][0]);
173
174		51711	s->misc_bits += get_bits_diff(s);
175			/* motion vector */
176		51711	ff_h263_pred_motion(&s->c, 0, 0, &pred_x, &pred_y);
177		51711	ff_msmpeg4_encode_motion(&w->msmpeg4, motion_x - pred_x,
178			motion_y - pred_y);
179		51711	s->mv_bits += get_bits_diff(s);
180			} else {
181			/* compute cbp */
182		8139	cbp = 0;
183		8139	coded_cbp = 0;
184	2/2 ✓ Branch 0 taken 48834 times. ✓ Branch 1 taken 8139 times.	56973	for (i = 0; i < 6; i++) {
185		48834	int val = (s->c.block_last_index[i] >= 1);
186
187		48834	cbp \|= val << (5 - i);
188	2/2 ✓ Branch 0 taken 32556 times. ✓ Branch 1 taken 16278 times.	48834	if (i < 4) {
189			/* predict value for close blocks only for luma */
190		32556	int pred = ff_msmpeg4_coded_block_pred(&s->c, i, &coded_block);
191		32556	*coded_block = val;
192		32556	val = val ^ pred;
193			}
194		48834	coded_cbp \|= val << (5 - i);
195			}
196
197	2/2 ✓ Branch 0 taken 5985 times. ✓ Branch 1 taken 2154 times.	8139	if (s->c.pict_type == AV_PICTURE_TYPE_I)
198		5985	put_bits(&s->pb,
199		5985	ff_msmp4_mb_i_table[coded_cbp][1],
200		5985	ff_msmp4_mb_i_table[coded_cbp][0]);
201			else
202		2154	put_bits(&s->pb,
203		2154	ff_wmv2_inter_table[w->cbp_table_index][cbp][1],
204		2154	ff_wmv2_inter_table[w->cbp_table_index][cbp][0]);
205		8139	put_bits(&s->pb, 1, 0); /* no AC prediction yet */
206	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 8139 times.	8139	if (s->c.inter_intra_pred) {
207		✗	s->c.h263_aic_dir = 0;
208		✗	put_bits(&s->pb,
209		✗	ff_table_inter_intra[s->c.h263_aic_dir][1],
210		✗	ff_table_inter_intra[s->c.h263_aic_dir][0]);
211			}
212		8139	s->misc_bits += get_bits_diff(s);
213			}
214
215	2/2 ✓ Branch 0 taken 359100 times. ✓ Branch 1 taken 59850 times.	418950	for (i = 0; i < 6; i++)
216		359100	ff_msmpeg4_encode_block(s, block[i], i);
217	2/2 ✓ Branch 0 taken 8139 times. ✓ Branch 1 taken 51711 times.	59850	if (s->c.mb_intra)
218		8139	s->i_tex_bits += get_bits_diff(s);
219			else
220		51711	s->p_tex_bits += get_bits_diff(s);
221		59850	}
222
223		4	static av_cold int wmv2_encode_init(AVCodecContext *avctx)
224			{
225		4	WMV2EncContext *const w = avctx->priv_data;
226		4	MPVEncContext *const s = &w->msmpeg4.m.s;
227			int ret;
228
229		4	w->msmpeg4.m.encode_picture_header = wmv2_encode_picture_header;
230		4	s->encode_mb = wmv2_encode_mb;
231		4	s->c.private_ctx = &w->common;
232		4	ret = ff_mpv_encode_init(avctx);
233	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 4 times.	4	if (ret < 0)
234		✗	return ret;
235
236		4	ff_wmv2_common_init(&s->c);
237
238		4	avctx->extradata_size = WMV2_EXTRADATA_SIZE;
239		4	avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
240	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 4 times.	4	if (!avctx->extradata)
241		✗	return AVERROR(ENOMEM);
242
243		4	encode_ext_header(w);
244
245		4	return 0;
246			}
247
248			const FFCodec ff_wmv2_encoder = {
249			.p.name = "wmv2",
250			CODEC_LONG_NAME("Windows Media Video 8"),
251			.p.type = AVMEDIA_TYPE_VIDEO,
252			.p.id = AV_CODEC_ID_WMV2,
253			.p.priv_class = &ff_mpv_enc_class,
254			.p.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
255			.priv_data_size = sizeof(WMV2EncContext),
256			.init = wmv2_encode_init,
257			FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
258			.close = ff_mpv_encode_end,
259			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
260			.color_ranges = AVCOL_RANGE_MPEG,
261			CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
262			};
263

Function (Line)	Call count	Block coverage
encode_ext_header (line 50)	called 4 times, returned 4 times	94.0%
wmv2_encode_init (line 223)	called 4 times, returned 4 times	80.0%
wmv2_encode_mb (line 153)	called 59850 times, returned 59850 times	97.0%
wmv2_encode_picture_header (line 76)	called 200 times, returned 200 times	90.0%