FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/pcm-bluray.c
Date: 2026-01-16 07:34:38
Exec Total Coverage
Lines: 0 147 0.0%
Functions: 0 2 0.0%
Branches: 0 64 0.0%
Line Branch Exec Source
1 /*
2 * LPCM codecs for PCM format found in Blu-ray PCM streams
3 * Copyright (c) 2009, 2013 Christian Schmidt
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 * PCM codec for Blu-ray PCM audio tracks
25 */
26
27 #include "libavutil/channel_layout.h"
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "codec_internal.h"
31 #include "decode.h"
32
33 /*
34 * Channel Mapping according to
35 * Blu-ray Disc Read-Only Format Version 1
36 * Part 3: Audio Visual Basic Specifications
37 * mono M1 X
38 * stereo L R
39 * 3/0 L R C X
40 * 2/1 L R S X
41 * 3/1 L R C S
42 * 2/2 L R LS RS
43 * 3/2 L R C LS RS X
44 * 3/2+lfe L R C LS RS lfe
45 * 3/4 L R C LS Rls Rrs RS X
46 * 3/4+lfe L R C LS Rls Rrs RS lfe
47 */
48
49 /**
50 * Parse the header of a LPCM frame read from a Blu-ray MPEG-TS stream
51 * @param avctx the codec context
52 * @param header pointer to the first four bytes of the data packet
53 */
54 ✗ static int pcm_bluray_parse_header(AVCodecContext *avctx,
55 const uint8_t *header)
56 {
57 static const uint8_t bits_per_samples[4] = { 0, 16, 20, 24 };
58 static const AVChannelLayout channel_layouts[16] = {
59 { 0 }, AV_CHANNEL_LAYOUT_MONO, { 0 },
60 AV_CHANNEL_LAYOUT_STEREO, AV_CHANNEL_LAYOUT_SURROUND, AV_CHANNEL_LAYOUT_2_1,
61 AV_CHANNEL_LAYOUT_4POINT0, AV_CHANNEL_LAYOUT_2_2, AV_CHANNEL_LAYOUT_5POINT0,
62 AV_CHANNEL_LAYOUT_5POINT1, AV_CHANNEL_LAYOUT_7POINT0, AV_CHANNEL_LAYOUT_7POINT1,
63 { 0 }, { 0 }, { 0 }, { 0 },
64 };
65 ✗ uint8_t channel_layout = header[2] >> 4;
66
67 ✗ if (avctx->debug & FF_DEBUG_PICT_INFO)
68 ff_dlog(avctx, "pcm_bluray_parse_header: header = %02x%02x%02x%02x\n",
69 header[0], header[1], header[2], header[3]);
70
71 /* get the sample depth and derive the sample format from it */
72 ✗ avctx->bits_per_coded_sample = bits_per_samples[header[3] >> 6];
73 ✗ if (!(avctx->bits_per_coded_sample == 16 || avctx->bits_per_coded_sample == 24)) {
74 ✗ av_log(avctx, AV_LOG_ERROR, "unsupported sample depth (%d)\n", avctx->bits_per_coded_sample);
75 ✗ return AVERROR_INVALIDDATA;
76 }
77 ✗ avctx->sample_fmt = avctx->bits_per_coded_sample == 16 ? AV_SAMPLE_FMT_S16
78 ✗ : AV_SAMPLE_FMT_S32;
79 ✗ if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
80 ✗ avctx->bits_per_raw_sample = avctx->bits_per_coded_sample;
81
82 /* get the sample rate. Not all values are used. */
83 ✗ switch (header[2] & 0x0f) {
84 ✗ case 1:
85 ✗ avctx->sample_rate = 48000;
86 ✗ break;
87 ✗ case 4:
88 ✗ avctx->sample_rate = 96000;
89 ✗ break;
90 ✗ case 5:
91 ✗ avctx->sample_rate = 192000;
92 ✗ break;
93 ✗ default:
94 ✗ avctx->sample_rate = 0;
95 ✗ av_log(avctx, AV_LOG_ERROR, "reserved sample rate (%d)\n",
96 ✗ header[2] & 0x0f);
97 ✗ return AVERROR_INVALIDDATA;
98 }
99
100 /*
101 * get the channel number (and mapping). Not all values are used.
102 * It must be noted that the number of channels in the MPEG stream can
103 * differ from the actual meaningful number, e.g. mono audio still has two
104 * channels, one being empty.
105 */
106 ✗ av_channel_layout_uninit(&avctx->ch_layout);
107 ✗ avctx->ch_layout = channel_layouts[channel_layout];
108 ✗ if (!avctx->ch_layout.nb_channels) {
109 ✗ av_log(avctx, AV_LOG_ERROR, "reserved channel configuration (%d)\n",
110 channel_layout);
111 ✗ return AVERROR_INVALIDDATA;
112 }
113
114 ✗ avctx->bit_rate = FFALIGN(avctx->ch_layout.nb_channels, 2) * avctx->sample_rate *
115 ✗ avctx->bits_per_coded_sample;
116
117 ✗ if (avctx->debug & FF_DEBUG_PICT_INFO)
118 ff_dlog(avctx,
119 "pcm_bluray_parse_header: %d channels, %d bits per sample, %d Hz, %"PRId64" bit/s\n",
120 avctx->ch_layout.nb_channels, avctx->bits_per_coded_sample,
121 avctx->sample_rate, avctx->bit_rate);
122 ✗ return 0;
123 }
124
125 ✗ static int pcm_bluray_decode_frame(AVCodecContext *avctx, AVFrame *frame,
126 int *got_frame_ptr, AVPacket *avpkt)
127 {
128 ✗ const uint8_t *src = avpkt->data;
129 ✗ int buf_size = avpkt->size;
130 GetByteContext gb;
131 int num_source_channels, channel, retval;
132 int sample_size, samples;
133 int16_t *dst16;
134 int32_t *dst32;
135
136 ✗ if (buf_size < 4) {
137 ✗ av_log(avctx, AV_LOG_ERROR, "PCM packet too small\n");
138 ✗ return AVERROR_INVALIDDATA;
139 }
140
141 ✗ if ((retval = pcm_bluray_parse_header(avctx, src)))
142 ✗ return retval;
143 ✗ src += 4;
144 ✗ buf_size -= 4;
145
146 ✗ bytestream2_init(&gb, src, buf_size);
147
148 /* There's always an even number of channels in the source */
149 ✗ num_source_channels = FFALIGN(avctx->ch_layout.nb_channels, 2);
150 ✗ sample_size = (num_source_channels *
151 ✗ (avctx->sample_fmt == AV_SAMPLE_FMT_S16 ? 16 : 24)) >> 3;
152 ✗ samples = buf_size / sample_size;
153
154 /* get output buffer */
155 ✗ frame->nb_samples = samples;
156 ✗ if ((retval = ff_get_buffer(avctx, frame, 0)) < 0)
157 ✗ return retval;
158 ✗ dst16 = (int16_t *)frame->data[0];
159 ✗ dst32 = (int32_t *)frame->data[0];
160
161 ✗ if (samples) {
162 ✗ switch (avctx->ch_layout.u.mask) {
163 /* cases with same number of source and coded channels */
164 ✗ case AV_CH_LAYOUT_STEREO:
165 case AV_CH_LAYOUT_4POINT0:
166 case AV_CH_LAYOUT_2_2:
167 ✗ samples *= num_source_channels;
168 ✗ if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
169 #if HAVE_BIGENDIAN
170 bytestream2_get_buffer(&gb, (uint8_t*)dst16, buf_size);
171 #else
172 do {
173 ✗ *dst16++ = bytestream2_get_be16u(&gb);
174 ✗ } while (--samples);
175 #endif
176 } else {
177 do {
178 ✗ *dst32++ = bytestream2_get_be24u(&gb) << 8;
179 ✗ } while (--samples);
180 }
181 ✗ break;
182 /* cases where number of source channels = coded channels + 1 */
183 ✗ case AV_CH_LAYOUT_MONO:
184 case AV_CH_LAYOUT_SURROUND:
185 case AV_CH_LAYOUT_2_1:
186 case AV_CH_LAYOUT_5POINT0:
187 ✗ if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
188 do {
189 #if HAVE_BIGENDIAN
190 bytestream2_get_buffer(&gb, (uint8_t*)dst16,
191 avctx->ch_layout.nb_channels * 2);
192 dst16 += avctx->ch_layout.nb_channels;
193 #else
194 ✗ channel = avctx->ch_layout.nb_channels;
195 do {
196 ✗ *dst16++ = bytestream2_get_be16u(&gb);
197 ✗ } while (--channel);
198 #endif
199 ✗ bytestream2_skip(&gb, 2);
200 ✗ } while (--samples);
201 } else {
202 do {
203 ✗ channel = avctx->ch_layout.nb_channels;
204 do {
205 ✗ *dst32++ = bytestream2_get_be24u(&gb) << 8;
206 ✗ } while (--channel);
207 ✗ bytestream2_skip(&gb, 3);
208 ✗ } while (--samples);
209 }
210 ✗ break;
211 /* remapping: L, R, C, LBack, RBack, LF */
212 ✗ case AV_CH_LAYOUT_5POINT1:
213 ✗ if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
214 do {
215 ✗ dst16[0] = bytestream2_get_be16u(&gb);
216 ✗ dst16[1] = bytestream2_get_be16u(&gb);
217 ✗ dst16[2] = bytestream2_get_be16u(&gb);
218 ✗ dst16[4] = bytestream2_get_be16u(&gb);
219 ✗ dst16[5] = bytestream2_get_be16u(&gb);
220 ✗ dst16[3] = bytestream2_get_be16u(&gb);
221 ✗ dst16 += 6;
222 ✗ } while (--samples);
223 } else {
224 do {
225 ✗ dst32[0] = bytestream2_get_be24u(&gb) << 8;
226 ✗ dst32[1] = bytestream2_get_be24u(&gb) << 8;
227 ✗ dst32[2] = bytestream2_get_be24u(&gb) << 8;
228 ✗ dst32[4] = bytestream2_get_be24u(&gb) << 8;
229 ✗ dst32[5] = bytestream2_get_be24u(&gb) << 8;
230 ✗ dst32[3] = bytestream2_get_be24u(&gb) << 8;
231 ✗ dst32 += 6;
232 ✗ } while (--samples);
233 }
234 ✗ break;
235 /* remapping: L, R, C, LSide, LBack, RBack, RSide, <unused> */
236 ✗ case AV_CH_LAYOUT_7POINT0:
237 ✗ if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
238 do {
239 ✗ dst16[0] = bytestream2_get_be16u(&gb);
240 ✗ dst16[1] = bytestream2_get_be16u(&gb);
241 ✗ dst16[2] = bytestream2_get_be16u(&gb);
242 ✗ dst16[5] = bytestream2_get_be16u(&gb);
243 ✗ dst16[3] = bytestream2_get_be16u(&gb);
244 ✗ dst16[4] = bytestream2_get_be16u(&gb);
245 ✗ dst16[6] = bytestream2_get_be16u(&gb);
246 ✗ dst16 += 7;
247 ✗ bytestream2_skip(&gb, 2);
248 ✗ } while (--samples);
249 } else {
250 do {
251 ✗ dst32[0] = bytestream2_get_be24u(&gb) << 8;
252 ✗ dst32[1] = bytestream2_get_be24u(&gb) << 8;
253 ✗ dst32[2] = bytestream2_get_be24u(&gb) << 8;
254 ✗ dst32[5] = bytestream2_get_be24u(&gb) << 8;
255 ✗ dst32[3] = bytestream2_get_be24u(&gb) << 8;
256 ✗ dst32[4] = bytestream2_get_be24u(&gb) << 8;
257 ✗ dst32[6] = bytestream2_get_be24u(&gb) << 8;
258 ✗ dst32 += 7;
259 ✗ bytestream2_skip(&gb, 3);
260 ✗ } while (--samples);
261 }
262 ✗ break;
263 /* remapping: L, R, C, LSide, LBack, RBack, RSide, LF */
264 ✗ case AV_CH_LAYOUT_7POINT1:
265 ✗ if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
266 do {
267 ✗ dst16[0] = bytestream2_get_be16u(&gb);
268 ✗ dst16[1] = bytestream2_get_be16u(&gb);
269 ✗ dst16[2] = bytestream2_get_be16u(&gb);
270 ✗ dst16[6] = bytestream2_get_be16u(&gb);
271 ✗ dst16[4] = bytestream2_get_be16u(&gb);
272 ✗ dst16[5] = bytestream2_get_be16u(&gb);
273 ✗ dst16[7] = bytestream2_get_be16u(&gb);
274 ✗ dst16[3] = bytestream2_get_be16u(&gb);
275 ✗ dst16 += 8;
276 ✗ } while (--samples);
277 } else {
278 do {
279 ✗ dst32[0] = bytestream2_get_be24u(&gb) << 8;
280 ✗ dst32[1] = bytestream2_get_be24u(&gb) << 8;
281 ✗ dst32[2] = bytestream2_get_be24u(&gb) << 8;
282 ✗ dst32[6] = bytestream2_get_be24u(&gb) << 8;
283 ✗ dst32[4] = bytestream2_get_be24u(&gb) << 8;
284 ✗ dst32[5] = bytestream2_get_be24u(&gb) << 8;
285 ✗ dst32[7] = bytestream2_get_be24u(&gb) << 8;
286 ✗ dst32[3] = bytestream2_get_be24u(&gb) << 8;
287 ✗ dst32 += 8;
288 ✗ } while (--samples);
289 }
290 ✗ break;
291 }
292 }
293
294 ✗ *got_frame_ptr = 1;
295
296 ✗ retval = bytestream2_tell(&gb);
297 ✗ if (avctx->debug & FF_DEBUG_BITSTREAM)
298 ff_dlog(avctx, "pcm_bluray_decode_frame: decoded %d -> %d bytes\n",
299 retval, buf_size);
300 ✗ return retval + 4;
301 }
302
303 const FFCodec ff_pcm_bluray_decoder = {
304 .p.name = "pcm_bluray",
305 CODEC_LONG_NAME("PCM signed 16|20|24-bit big-endian for Blu-ray media"),
306 .p.type = AVMEDIA_TYPE_AUDIO,
307 .p.id = AV_CODEC_ID_PCM_BLURAY,
308 FF_CODEC_DECODE_CB(pcm_bluray_decode_frame),
309 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
310 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32),
311 };
312