FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavformat/lvfdec.c
Date: 2022-12-09 07:38:14
Exec Total Coverage
Lines: 3 87 3.4%
Functions: 1 3 33.3%
Branches: 1 35 2.9%

Line Branch Exec Source
1 /*
2 * LVF demuxer
3 * Copyright (c) 2012 Paul B Mahol
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 #include "libavutil/intreadwrite.h"
23 #include "avformat.h"
24 #include "riff.h"
25
26 6782 static int lvf_probe(const AVProbeData *p)
27 {
28
1/2
✓ Branch 0 taken 6782 times.
✗ Branch 1 not taken.
6782 if (AV_RL32(p->buf) != MKTAG('L', 'V', 'F', 'F'))
29 6782 return 0;
30
31 if (!AV_RL32(p->buf + 16) || AV_RL32(p->buf + 16) > 256)
32 return AVPROBE_SCORE_MAX / 8;
33
34 return AVPROBE_SCORE_EXTENSION;
35 }
36
37 static int lvf_read_header(AVFormatContext *s)
38 {
39 AVStream *st;
40 int64_t next_offset;
41 unsigned size, nb_streams, id;
42
43 avio_skip(s->pb, 16);
44 nb_streams = avio_rl32(s->pb);
45 if (!nb_streams)
46 return AVERROR_INVALIDDATA;
47 if (nb_streams > 2) {
48 avpriv_request_sample(s, "%d streams", nb_streams);
49 return AVERROR_PATCHWELCOME;
50 }
51
52 avio_skip(s->pb, 1012);
53
54 while (!avio_feof(s->pb)) {
55 id = avio_rl32(s->pb);
56 size = avio_rl32(s->pb);
57 next_offset = avio_tell(s->pb) + size;
58
59 switch (id) {
60 case MKTAG('0', '0', 'f', 'm'):
61 st = avformat_new_stream(s, 0);
62 if (!st)
63 return AVERROR(ENOMEM);
64
65 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
66 avio_skip(s->pb, 4);
67 st->codecpar->width = avio_rl32(s->pb);
68 st->codecpar->height = avio_rl32(s->pb);
69 avio_skip(s->pb, 4);
70 st->codecpar->codec_tag = avio_rl32(s->pb);
71 st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags,
72 st->codecpar->codec_tag);
73 avpriv_set_pts_info(st, 32, 1, 1000);
74 break;
75 case MKTAG('0', '1', 'f', 'm'):
76 st = avformat_new_stream(s, 0);
77 if (!st)
78 return AVERROR(ENOMEM);
79
80 st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
81 st->codecpar->codec_tag = avio_rl16(s->pb);
82 st->codecpar->ch_layout.nb_channels = avio_rl16(s->pb);
83 st->codecpar->sample_rate = avio_rl16(s->pb);
84 avio_skip(s->pb, 8);
85 st->codecpar->bits_per_coded_sample = avio_r8(s->pb);
86 st->codecpar->codec_id = ff_codec_get_id(ff_codec_wav_tags,
87 st->codecpar->codec_tag);
88 avpriv_set_pts_info(st, 32, 1, 1000);
89 break;
90 case 0:
91 avio_seek(s->pb, 2048 + 8, SEEK_SET);
92 return 0;
93 default:
94 avpriv_request_sample(s, "id %d", id);
95 return AVERROR_PATCHWELCOME;
96 }
97
98 avio_seek(s->pb, next_offset, SEEK_SET);
99 }
100
101 return AVERROR_EOF;
102 }
103
104 static int lvf_read_packet(AVFormatContext *s, AVPacket *pkt)
105 {
106 unsigned size, flags, timestamp, id;
107 int64_t pos;
108 int ret, is_video = 0;
109 int stream_index;
110
111 pos = avio_tell(s->pb);
112 while (!avio_feof(s->pb)) {
113 id = avio_rl32(s->pb);
114 size = avio_rl32(s->pb);
115
116 if (size == 0xFFFFFFFFu)
117 return AVERROR_EOF;
118
119 switch (id) {
120 case MKTAG('0', '0', 'd', 'c'):
121 is_video = 1;
122 case MKTAG('0', '1', 'w', 'b'):
123 if (size < 8)
124 return AVERROR_INVALIDDATA;
125 stream_index = is_video ? 0 : 1;
126 if (stream_index >= s->nb_streams)
127 return AVERROR_INVALIDDATA;
128 timestamp = avio_rl32(s->pb);
129 flags = avio_rl32(s->pb);
130 ret = av_get_packet(s->pb, pkt, size - 8);
131 if (flags & (1 << 12))
132 pkt->flags |= AV_PKT_FLAG_KEY;
133 pkt->stream_index = stream_index;
134 pkt->pts = timestamp;
135 pkt->pos = pos;
136 return ret;
137 default:
138 ret = avio_skip(s->pb, size);
139 }
140
141 if (ret < 0)
142 return ret;
143 }
144
145 return AVERROR_EOF;
146 }
147
148 const AVInputFormat ff_lvf_demuxer = {
149 .name = "lvf",
150 .long_name = NULL_IF_CONFIG_SMALL("LVF"),
151 .read_probe = lvf_probe,
152 .read_header = lvf_read_header,
153 .read_packet = lvf_read_packet,
154 .extensions = "lvf",
155 .flags = AVFMT_GENERIC_INDEX,
156 };
157