教育部：严厉打击自主招生中论文买卖和造假等

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

	Exec	Total	Coverage
Lines:	71	86	82.6%
Functions:	1	2	50.0%
Branches:	31	40	77.5%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2018 Paul B Mahol
    
       *
    
       * 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 "bsf.h"
    
      #include "bsf_internal.h"
    
      #include "get_bits.h"
    
      #include "mlp_parse.h"
    
      #include "mlp.h"
    
      typedef struct AccessUnit {
    
          uint8_t bits[4];
    
          uint16_t offset;
    
          uint16_t optional;
    
      } AccessUnit;
    
      typedef struct TrueHDCoreContext {
    
          MLPHeaderInfo hdr;
    
      } TrueHDCoreContext;
    
      257
      static int truehd_core_filter(AVBSFContext *ctx, AVPacket *pkt)
    
      {
    
      257
          TrueHDCoreContext *s = ctx->priv_data;
    
          GetBitContext gbc;
    
          AccessUnit units[MAX_SUBSTREAMS];
    
      257
          int ret, i, last_offset = 0;
    
          int in_size, out_size;
    
      257
          int have_header = 0;
    
      257
          int substream_bytes = 0;
    
          int end;
    
      257
          ret = ff_bsf_get_packet_ref(ctx, pkt);
    
        2/2✓ Branch 0 taken 129 times.
✓ Branch 1 taken 128 times.

      257
          if (ret < 0)
    
      129
              return ret;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.

      128
          if (pkt->size < 4) {
    
      ✗
              ret = AVERROR_INVALIDDATA;
    
      ✗
              goto fail;
    
          }
    
      128
          in_size = (AV_RB16(pkt->data) & 0xFFF) * 2;
    
        2/4✓ Branch 0 taken 128 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 128 times.

      128
          if (in_size < 4 || in_size > pkt->size) {
    
      ✗
              ret = AVERROR_INVALIDDATA;
    
      ✗
              goto fail;
    
          }
    
      128
          ret = init_get_bits8(&gbc, pkt->data + 4, pkt->size - 4);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.

      128
          if (ret < 0)
    
      ✗
              goto fail;
    
        2/2✓ Branch 1 taken 1 times.
✓ Branch 2 taken 127 times.

      128
          if (show_bits_long(&gbc, 32) == 0xf8726fba) {
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.

      1
              if ((ret = ff_mlp_read_major_sync(ctx, &s->hdr, &gbc)) < 0)
    
      ✗
                  goto fail;
    
      1
              have_header = 1;
    
          }
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.

      128
          if (s->hdr.num_substreams > MAX_SUBSTREAMS) {
    
      ✗
              ret = AVERROR_INVALIDDATA;
    
      ✗
              goto fail;
    
          }
    
        2/2✓ Branch 0 taken 512 times.
✓ Branch 1 taken 128 times.

      640
          for (i = 0; i < s->hdr.num_substreams; i++) {
    
        2/2✓ Branch 0 taken 2048 times.
✓ Branch 1 taken 512 times.

      2560
              for (int j = 0; j < 4; j++)
    
      2048
                  units[i].bits[j] = get_bits1(&gbc);
    
      512
              units[i].offset = get_bits(&gbc, 12);
    
        2/2✓ Branch 0 taken 384 times.
✓ Branch 1 taken 128 times.

      512
              if (i < 3) {
    
      384
                  last_offset = units[i].offset * 2;
    
      384
                  substream_bytes += 2;
    
              }
    
        2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 508 times.

      512
              if (units[i].bits[0]) {
    
      4
                  units[i].optional = get_bits(&gbc, 16);
    
        2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.

      4
                  if (i < 3)
    
      3
                      substream_bytes += 2;
    
              }
    
          }
    
      128
          end = get_bits_count(&gbc) >> 3;
    
      128
          out_size = end + 4 + last_offset;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.

      128
          if (out_size < in_size) {
    
      128
              int bpos = 0, reduce = end - have_header * 28 - substream_bytes;
    
      128
              uint16_t parity_nibble, dts = AV_RB16(pkt->data + 2);
    
              uint16_t auheader;
    
              uint8_t header[28];
    
              av_assert1(reduce >= 0 && reduce % 2 == 0);
    
        2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 127 times.

      128
              if (have_header) {
    
      1
                  memcpy(header, pkt->data + 4, 28);
    
      1
                  header[16]  = (header[16] & 0x0c) | (FFMIN(s->hdr.num_substreams, 3) << 4);
    
      1
                  header[17] &= 0x7f;
    
      1
                  header[25] &= 0xfe;
    
      1
                  AV_WL16(header + 26, ff_mlp_checksum16(header, 26));
    
              }
    
      128
              pkt->data += reduce;
    
      128
              out_size  -= reduce;
    
      128
              pkt->size  = out_size;
    
      128
              ret = av_packet_make_writable(pkt);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.

      128
              if (ret < 0)
    
      ✗
                  goto fail;
    
      128
              AV_WB16(pkt->data + 2, dts);
    
      128
              parity_nibble = dts;
    
      128
              parity_nibble ^= out_size / 2;
    
        2/2✓ Branch 0 taken 384 times.
✓ Branch 1 taken 128 times.

      512
              for (i = 0; i < FFMIN(s->hdr.num_substreams, 3); i++) {
    
      384
                  uint16_t substr_hdr = 0;
    
      384
                  substr_hdr |= (units[i].bits[0] << 15);
    
      384
                  substr_hdr |= (units[i].bits[1] << 14);
    
      384
                  substr_hdr |= (units[i].bits[2] << 13);
    
      384
                  substr_hdr |= (units[i].bits[3] << 12);
    
      384
                  substr_hdr |=  units[i].offset;
    
      384
                  AV_WB16(pkt->data + have_header * 28 + 4 + bpos, substr_hdr);
    
      384
                  parity_nibble ^= substr_hdr;
    
      384
                  bpos          += 2;
    
        2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 381 times.

      384
                  if (units[i].bits[0]) {
    
      3
                      AV_WB16(pkt->data + have_header * 28 + 4 + bpos, units[i].optional);
    
      3
                      parity_nibble ^= units[i].optional;
    
      3
                      bpos          += 2;
    
                  }
    
              }
    
      128
              parity_nibble ^= parity_nibble >> 8;
    
      128
              parity_nibble ^= parity_nibble >> 4;
    
      128
              parity_nibble &= 0xF;
    
      128
              auheader  = (parity_nibble ^ 0xF) << 12;
    
      128
              auheader |= (out_size / 2) & 0x0fff;
    
      128
              AV_WB16(pkt->data, auheader);
    
        2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 127 times.

      128
              if (have_header)
    
      1
                  memcpy(pkt->data + 4, header, 28);
    
          }
    
      ✗
      fail:
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.

      128
          if (ret < 0)
    
      ✗
              av_packet_unref(pkt);
    
      128
          return ret;
    
      }
    
      ✗
      static void truehd_core_flush(AVBSFContext *ctx)
    
      {
    
      ✗
          TrueHDCoreContext *s = ctx->priv_data;
    
      ✗
          memset(&s->hdr, 0, sizeof(s->hdr));
    
      ✗
      }
    
      static const enum AVCodecID codec_ids[] = {
    
          AV_CODEC_ID_TRUEHD, AV_CODEC_ID_NONE,
    
      };
    
      const FFBitStreamFilter ff_truehd_core_bsf = {
    
          .p.name         = "truehd_core",
    
          .p.codec_ids    = codec_ids,
    
          .priv_data_size = sizeof(TrueHDCoreContext),
    
          .filter         = truehd_core_filter,
    
          .flush          = truehd_core_flush,
    
      };

心肺气虚吃什么中成药	省军区司令员是什么级别	大云是什么	性功能障碍挂什么科	洗面奶和洁面乳有什么区别
血糖高初期有什么症状	属猴的什么命	番茄和西红柿有什么区别	断生是什么意思啊	为什么耳鸣
性功能下降是什么原因	1972年属鼠的是什么命	依托是什么意思	天道好轮回什么意思	hiit是什么意思
蜂蜜什么时候喝最好	痤疮是由什么引起的	纯钛对人体有什么好处	如意丹的作用是什么	舌苔黑是什么病

rose是什么意思gangsutong.com	三伏天吃什么好hcv9jop5ns0r.cn	唯有读书高的前一句是什么hcv9jop3ns8r.cn	为什么文化大革命hcv8jop3ns2r.cn	姜字五行属什么hcv8jop5ns6r.cn
木危读什么youbangsi.com	膝盖缝里面疼什么原因hcv8jop7ns2r.cn	脚腕肿是什么原因hcv9jop4ns7r.cn	掉睫毛是什么原因hcv8jop1ns3r.cn	什么蚌相争hcv9jop3ns0r.cn
家财万贯是什么生肖hcv9jop6ns7r.cn	呼吸音粗是什么原因bjcbxg.com	队友是什么意思hcv7jop5ns2r.cn	导管子是什么意思hcv8jop8ns7r.cn	天地始交是什么意思hcv9jop7ns0r.cn
鼻子痒是什么原因hcv9jop6ns9r.cn	低血压平时要注意什么hcv8jop0ns1r.cn	鱼胶是什么东西hcv9jop4ns2r.cn	三点水一个前读什么hcv8jop8ns0r.cn	过生日送男朋友什么礼物好hcv9jop7ns2r.cn

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2018 Paul B Mahol
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 "bsf.h"
22			#include "bsf_internal.h"
23			#include "get_bits.h"
24			#include "mlp_parse.h"
25			#include "mlp.h"
26
27			typedef struct AccessUnit {
28			uint8_t bits[4];
29			uint16_t offset;
30			uint16_t optional;
31			} AccessUnit;
32
33			typedef struct TrueHDCoreContext {
34			MLPHeaderInfo hdr;
35			} TrueHDCoreContext;
36
37		257	static int truehd_core_filter(AVBSFContext ctx, AVPacket pkt)
38			{
39		257	TrueHDCoreContext *s = ctx->priv_data;
40			GetBitContext gbc;
41			AccessUnit units[MAX_SUBSTREAMS];
42		257	int ret, i, last_offset = 0;
43			int in_size, out_size;
44		257	int have_header = 0;
45		257	int substream_bytes = 0;
46			int end;
47
48		257	ret = ff_bsf_get_packet_ref(ctx, pkt);
49	2/2 ✓ Branch 0 taken 129 times. ✓ Branch 1 taken 128 times.	257	if (ret < 0)
50		129	return ret;
51
52	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 128 times.	128	if (pkt->size < 4) {
53		✗	ret = AVERROR_INVALIDDATA;
54		✗	goto fail;
55			}
56
57		128	in_size = (AV_RB16(pkt->data) & 0xFFF) * 2;
58	2/4 ✓ Branch 0 taken 128 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 128 times.	128	if (in_size < 4 \|\| in_size > pkt->size) {
59		✗	ret = AVERROR_INVALIDDATA;
60		✗	goto fail;
61			}
62
63		128	ret = init_get_bits8(&gbc, pkt->data + 4, pkt->size - 4);
64	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 128 times.	128	if (ret < 0)
65		✗	goto fail;
66
67	2/2 ✓ Branch 1 taken 1 times. ✓ Branch 2 taken 127 times.	128	if (show_bits_long(&gbc, 32) == 0xf8726fba) {
68	1/2 ✗ Branch 1 not taken. ✓ Branch 2 taken 1 times.	1	if ((ret = ff_mlp_read_major_sync(ctx, &s->hdr, &gbc)) < 0)
69		✗	goto fail;
70		1	have_header = 1;
71			}
72
73	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 128 times.	128	if (s->hdr.num_substreams > MAX_SUBSTREAMS) {
74		✗	ret = AVERROR_INVALIDDATA;
75		✗	goto fail;
76			}
77
78	2/2 ✓ Branch 0 taken 512 times. ✓ Branch 1 taken 128 times.	640	for (i = 0; i < s->hdr.num_substreams; i++) {
79	2/2 ✓ Branch 0 taken 2048 times. ✓ Branch 1 taken 512 times.	2560	for (int j = 0; j < 4; j++)
80		2048	units[i].bits[j] = get_bits1(&gbc);
81
82		512	units[i].offset = get_bits(&gbc, 12);
83	2/2 ✓ Branch 0 taken 384 times. ✓ Branch 1 taken 128 times.	512	if (i < 3) {
84		384	last_offset = units[i].offset * 2;
85		384	substream_bytes += 2;
86			}
87
88	2/2 ✓ Branch 0 taken 4 times. ✓ Branch 1 taken 508 times.	512	if (units[i].bits[0]) {
89		4	units[i].optional = get_bits(&gbc, 16);
90	2/2 ✓ Branch 0 taken 3 times. ✓ Branch 1 taken 1 times.	4	if (i < 3)
91		3	substream_bytes += 2;
92			}
93			}
94		128	end = get_bits_count(&gbc) >> 3;
95
96		128	out_size = end + 4 + last_offset;
97	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 128 times.	128	if (out_size < in_size) {
98		128	int bpos = 0, reduce = end - have_header * 28 - substream_bytes;
99		128	uint16_t parity_nibble, dts = AV_RB16(pkt->data + 2);
100			uint16_t auheader;
101			uint8_t header[28];
102
103			av_assert1(reduce >= 0 && reduce % 2 == 0);
104
105	2/2 ✓ Branch 0 taken 1 times. ✓ Branch 1 taken 127 times.	128	if (have_header) {
106		1	memcpy(header, pkt->data + 4, 28);
107		1	header[16] = (header[16] & 0x0c) \| (FFMIN(s->hdr.num_substreams, 3) << 4);
108		1	header[17] &= 0x7f;
109		1	header[25] &= 0xfe;
110		1	AV_WL16(header + 26, ff_mlp_checksum16(header, 26));
111			}
112
113		128	pkt->data += reduce;
114		128	out_size -= reduce;
115		128	pkt->size = out_size;
116
117		128	ret = av_packet_make_writable(pkt);
118	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 128 times.	128	if (ret < 0)
119		✗	goto fail;
120
121		128	AV_WB16(pkt->data + 2, dts);
122		128	parity_nibble = dts;
123		128	parity_nibble ^= out_size / 2;
124
125	2/2 ✓ Branch 0 taken 384 times. ✓ Branch 1 taken 128 times.	512	for (i = 0; i < FFMIN(s->hdr.num_substreams, 3); i++) {
126		384	uint16_t substr_hdr = 0;
127
128		384	substr_hdr \|= (units[i].bits[0] << 15);
129		384	substr_hdr \|= (units[i].bits[1] << 14);
130		384	substr_hdr \|= (units[i].bits[2] << 13);
131		384	substr_hdr \|= (units[i].bits[3] << 12);
132		384	substr_hdr \|= units[i].offset;
133
134		384	AV_WB16(pkt->data + have_header * 28 + 4 + bpos, substr_hdr);
135
136		384	parity_nibble ^= substr_hdr;
137		384	bpos += 2;
138
139	2/2 ✓ Branch 0 taken 3 times. ✓ Branch 1 taken 381 times.	384	if (units[i].bits[0]) {
140		3	AV_WB16(pkt->data + have_header * 28 + 4 + bpos, units[i].optional);
141
142		3	parity_nibble ^= units[i].optional;
143		3	bpos += 2;
144			}
145			}
146
147		128	parity_nibble ^= parity_nibble >> 8;
148		128	parity_nibble ^= parity_nibble >> 4;
149		128	parity_nibble &= 0xF;
150
151		128	auheader = (parity_nibble ^ 0xF) << 12;
152		128	auheader \|= (out_size / 2) & 0x0fff;
153		128	AV_WB16(pkt->data, auheader);
154
155	2/2 ✓ Branch 0 taken 1 times. ✓ Branch 1 taken 127 times.	128	if (have_header)
156		1	memcpy(pkt->data + 4, header, 28);
157			}
158
159		✗	fail:
160	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 128 times.	128	if (ret < 0)
161		✗	av_packet_unref(pkt);
162
163		128	return ret;
164			}
165
166		✗	static void truehd_core_flush(AVBSFContext *ctx)
167			{
168		✗	TrueHDCoreContext *s = ctx->priv_data;
169		✗	memset(&s->hdr, 0, sizeof(s->hdr));
170		✗	}
171
172			static const enum AVCodecID codec_ids[] = {
173			AV_CODEC_ID_TRUEHD, AV_CODEC_ID_NONE,
174			};
175
176			const FFBitStreamFilter ff_truehd_core_bsf = {
177			.p.name = "truehd_core",
178			.p.codec_ids = codec_ids,
179			.priv_data_size = sizeof(TrueHDCoreContext),
180			.filter = truehd_core_filter,
181			.flush = truehd_core_flush,
182			};
183

Function (Line)	Call count	Block coverage
truehd_core_filter (line 37)	called 257 times, returned 257 times	85.0%
truehd_core_flush (line 166)	not called	0.0%