FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/pcm-dvd.c	Lines:	85	151	56.3 %
Date:	2020-04-02 05:41:20	Branches:	28	59	47.5 %


/*
 * LPCM codecs for PCM formats found in Video DVD streams
 * Copyright (c) 2013 Christian Schmidt
 *
 * 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
 */

/**
 * @file
 * LPCM codecs for PCM formats found in Video DVD streams
 */

#include "avcodec.h"
#include "bytestream.h"
#include "internal.h"

typedef struct PCMDVDContext {
    uint32_t last_header;    // Cached header to see if parsing is needed
    int block_size;          // Size of a block of samples in bytes
    int last_block_size;     // Size of the last block of samples in bytes
    int samples_per_block;   // Number of samples per channel per block
    int groups_per_block;    // Number of 20/24-bit sample groups per block
    uint8_t *extra_samples;  // Pointer to leftover samples from a frame
    int extra_sample_count;  // Number of leftover samples in the buffer
} PCMDVDContext;

static av_cold int pcm_dvd_decode_init(AVCodecContext *avctx)
{
    PCMDVDContext *s = avctx->priv_data;

    /* Invalid header to force parsing of the first header */
    s->last_header = -1;
    /* reserve space for 8 channels, 3 bytes/sample, 4 samples/block */
    if (!(s->extra_samples = av_malloc(8 * 3 * 4)))
        return AVERROR(ENOMEM);

    return 0;
}

static av_cold int pcm_dvd_decode_uninit(AVCodecContext *avctx)
{
    PCMDVDContext *s = avctx->priv_data;

    av_freep(&s->extra_samples);

    return 0;
}

static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
{
    /* no traces of 44100 and 32000Hz in any commercial software or player */
    static const uint32_t frequencies[4] = { 48000, 96000, 44100, 32000 };
    PCMDVDContext *s = avctx->priv_data;
    int header_int = (header[0] & 0xe0) | (header[1] << 8) | (header[2] << 16);

    /* early exit if the header didn't change apart from the frame number */
    if (s->last_header == header_int)
        return 0;
    s->last_header = -1;

    if (avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(avctx, AV_LOG_DEBUG, "pcm_dvd_parse_header: header = %02x%02x%02x\n",
                header[0], header[1], header[2]);
    /*
     * header[0] emphasis (1), muse(1), reserved(1), frame number(5)
     * header[1] quant (2), freq(2), reserved(1), channels(3)
     * header[2] dynamic range control (0x80 = off)
     */

    /* Discard potentially existing leftover samples from old channel layout */
    s->extra_sample_count = 0;

    /* get the sample depth and derive the sample format from it */
    avctx->bits_per_coded_sample = 16 + (header[1] >> 6 & 3) * 4;
    if (avctx->bits_per_coded_sample == 28) {
        av_log(avctx, AV_LOG_ERROR,
               "PCM DVD unsupported sample depth %i\n",
               avctx->bits_per_coded_sample);
        return AVERROR_INVALIDDATA;
    }
    avctx->sample_fmt = avctx->bits_per_coded_sample == 16 ? AV_SAMPLE_FMT_S16
                                                           : AV_SAMPLE_FMT_S32;
    avctx->bits_per_raw_sample = avctx->bits_per_coded_sample;

    /* get the sample rate */
    avctx->sample_rate = frequencies[header[1] >> 4 & 3];

    /* get the number of channels */
    avctx->channels = 1 + (header[1] & 7);
    /* calculate the bitrate */
    avctx->bit_rate = avctx->channels *
                      avctx->sample_rate *
                      avctx->bits_per_coded_sample;

    /* 4 samples form a group in 20/24-bit PCM on DVD Video.
     * A block is formed by the number of groups that are
     * needed to complete a set of samples for each channel. */
    if (avctx->bits_per_coded_sample == 16) {
        s->samples_per_block = 1;
        s->block_size        = avctx->channels * 2;
    } else {
        switch (avctx->channels) {
        case 1:
        case 2:
        case 4:
            /* one group has all the samples needed */
            s->block_size        = 4 * avctx->bits_per_coded_sample / 8;
            s->samples_per_block = 4 / avctx->channels;
            s->groups_per_block  = 1;
            break;
        case 8:
            /* two groups have all the samples needed */
            s->block_size        = 8 * avctx->bits_per_coded_sample / 8;
            s->samples_per_block = 1;
            s->groups_per_block  = 2;
            break;
        default:
            /* need avctx->channels groups */
            s->block_size        = 4 * avctx->channels *
                                   avctx->bits_per_coded_sample / 8;
            s->samples_per_block = 4;
            s->groups_per_block  = avctx->channels;
            break;
        }
    }

    if (avctx->debug & FF_DEBUG_PICT_INFO)
        ff_dlog(avctx,
                "pcm_dvd_parse_header: %d channels, %d bits per sample, %d Hz, %"PRId64" bit/s\n",
                avctx->channels, avctx->bits_per_coded_sample,
                avctx->sample_rate, avctx->bit_rate);

    s->last_header = header_int;

    return 0;
}

static void *pcm_dvd_decode_samples(AVCodecContext *avctx, const uint8_t *src,
                                    void *dst, int blocks)
{
    PCMDVDContext *s = avctx->priv_data;
    int16_t *dst16   = dst;
    int32_t *dst32   = dst;
    GetByteContext gb;
    int i;
    uint8_t t;

    bytestream2_init(&gb, src, blocks * s->block_size);
    switch (avctx->bits_per_coded_sample) {
    case 16: {
#if HAVE_BIGENDIAN
        bytestream2_get_buffer(&gb, dst16, blocks * s->block_size);
        dst16 += blocks * s->block_size / 2;
#else
        int samples = blocks * avctx->channels;
        do {
            *dst16++ = bytestream2_get_be16u(&gb);
        } while (--samples);
#endif
        return dst16;
    }
    case 20:
        if (avctx->channels == 1) {
            do {
                for (i = 2; i; i--) {
                    dst32[0] = bytestream2_get_be16u(&gb) << 16;
                    dst32[1] = bytestream2_get_be16u(&gb) << 16;
                    t = bytestream2_get_byteu(&gb);
                    *dst32++ += (t & 0xf0) << 8;
                    *dst32++ += (t & 0x0f) << 12;
                }
            } while (--blocks);
        } else {
        do {
            for (i = s->groups_per_block; i; i--) {
                dst32[0] = bytestream2_get_be16u(&gb) << 16;
                dst32[1] = bytestream2_get_be16u(&gb) << 16;
                dst32[2] = bytestream2_get_be16u(&gb) << 16;
                dst32[3] = bytestream2_get_be16u(&gb) << 16;
                t = bytestream2_get_byteu(&gb);
                *dst32++ += (t & 0xf0) << 8;
                *dst32++ += (t & 0x0f) << 12;
                t = bytestream2_get_byteu(&gb);
                *dst32++ += (t & 0xf0) << 8;
                *dst32++ += (t & 0x0f) << 12;
            }
        } while (--blocks);
        }
        return dst32;
    case 24:
        if (avctx->channels == 1) {
            do {
                for (i = 2; i; i--) {
                    dst32[0] = bytestream2_get_be16u(&gb) << 16;
                    dst32[1] = bytestream2_get_be16u(&gb) << 16;
                    *dst32++ += bytestream2_get_byteu(&gb) << 8;
                    *dst32++ += bytestream2_get_byteu(&gb) << 8;
                }
            } while (--blocks);
        } else {
        do {
            for (i = s->groups_per_block; i; i--) {
                dst32[0] = bytestream2_get_be16u(&gb) << 16;
                dst32[1] = bytestream2_get_be16u(&gb) << 16;
                dst32[2] = bytestream2_get_be16u(&gb) << 16;
                dst32[3] = bytestream2_get_be16u(&gb) << 16;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
            }
        } while (--blocks);
        }
        return dst32;
    default:
        return NULL;
    }
}

static int pcm_dvd_decode_frame(AVCodecContext *avctx, void *data,
                                int *got_frame_ptr, AVPacket *avpkt)
{
    AVFrame *frame     = data;
    const uint8_t *src = avpkt->data;
    int buf_size       = avpkt->size;
    PCMDVDContext *s   = avctx->priv_data;
    int retval;
    int blocks;
    void *dst;

    if (buf_size < 3) {
        av_log(avctx, AV_LOG_ERROR, "PCM packet too small\n");
        return AVERROR_INVALIDDATA;
    }

    if ((retval = pcm_dvd_parse_header(avctx, src)))
        return retval;
    if (s->last_block_size && s->last_block_size != s->block_size) {
        av_log(avctx, AV_LOG_WARNING, "block_size has changed %d != %d\n", s->last_block_size, s->block_size);
        s->extra_sample_count = 0;
    }
    s->last_block_size = s->block_size;
    src      += 3;
    buf_size -= 3;

    blocks = (buf_size + s->extra_sample_count) / s->block_size;

    /* get output buffer */
    frame->nb_samples = blocks * s->samples_per_block;
    if ((retval = ff_get_buffer(avctx, frame, 0)) < 0)
        return retval;
    dst = frame->data[0];

    /* consume leftover samples from last packet */
    if (s->extra_sample_count) {
        int missing_samples = s->block_size - s->extra_sample_count;
        if (buf_size >= missing_samples) {
            memcpy(s->extra_samples + s->extra_sample_count, src,
                   missing_samples);
            dst = pcm_dvd_decode_samples(avctx, s->extra_samples, dst, 1);
            src += missing_samples;
            buf_size -= missing_samples;
            s->extra_sample_count = 0;
            blocks--;
        } else {
            /* new packet still doesn't have enough samples */
            memcpy(s->extra_samples + s->extra_sample_count, src, buf_size);
            s->extra_sample_count += buf_size;
            return avpkt->size;
        }
    }

    /* decode remaining complete samples */
    if (blocks) {
        pcm_dvd_decode_samples(avctx, src, dst, blocks);
        buf_size -= blocks * s->block_size;
    }

    /* store leftover samples */
    if (buf_size) {
        src += blocks * s->block_size;
        memcpy(s->extra_samples, src, buf_size);
        s->extra_sample_count = buf_size;
    }

    *got_frame_ptr = 1;

    return avpkt->size;
}

AVCodec ff_pcm_dvd_decoder = {
    .name           = "pcm_dvd",
    .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 16|20|24-bit big-endian for DVD media"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_PCM_DVD,
    .priv_data_size = sizeof(PCMDVDContext),
    .init           = pcm_dvd_decode_init,
    .decode         = pcm_dvd_decode_frame,
    .close          = pcm_dvd_decode_uninit,
    .capabilities   = AV_CODEC_CAP_DR1,
    .sample_fmts    = (const enum AVSampleFormat[]) {
        AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE
    }
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* LPCM codecs for PCM formats found in Video DVD streams
3			* Copyright (c) 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			* LPCM codecs for PCM formats found in Video DVD streams
25			*/
26
27			#include "avcodec.h"
28			#include "bytestream.h"
29			#include "internal.h"
30
31			typedef struct PCMDVDContext {
32			uint32_t last_header; // Cached header to see if parsing is needed
33			int block_size; // Size of a block of samples in bytes
34			int last_block_size; // Size of the last block of samples in bytes
35			int samples_per_block; // Number of samples per channel per block
36			int groups_per_block; // Number of 20/24-bit sample groups per block
37			uint8_t *extra_samples; // Pointer to leftover samples from a frame
38			int extra_sample_count; // Number of leftover samples in the buffer
39			} PCMDVDContext;
40
41		4	static av_cold int pcm_dvd_decode_init(AVCodecContext *avctx)
42			{
43		4	PCMDVDContext *s = avctx->priv_data;
44
45			/* Invalid header to force parsing of the first header */
46		4	s->last_header = -1;
47			/* reserve space for 8 channels, 3 bytes/sample, 4 samples/block */
48	✗✓	4	if (!(s->extra_samples = av_malloc(8 * 3 * 4)))
49			return AVERROR(ENOMEM);
50
51		4	return 0;
52			}
53
54		4	static av_cold int pcm_dvd_decode_uninit(AVCodecContext *avctx)
55			{
56		4	PCMDVDContext *s = avctx->priv_data;
57
58		4	av_freep(&s->extra_samples);
59
60		4	return 0;
61			}
62
63		126	static int pcm_dvd_parse_header(AVCodecContext avctx, const uint8_t header)
64			{
65			/* no traces of 44100 and 32000Hz in any commercial software or player */
66			static const uint32_t frequencies[4] = { 48000, 96000, 44100, 32000 };
67		126	PCMDVDContext *s = avctx->priv_data;
68		126	int header_int = (header[0] & 0xe0) \| (header[1] << 8) \| (header[2] << 16);
69
70			/* early exit if the header didn't change apart from the frame number */
71	✓✓	126	if (s->last_header == header_int)
72		122	return 0;
73		4	s->last_header = -1;
74
75	✗✓	4	if (avctx->debug & FF_DEBUG_PICT_INFO)
76			av_log(avctx, AV_LOG_DEBUG, "pcm_dvd_parse_header: header = %02x%02x%02x\n",
77			header[0], header[1], header[2]);
78			/*
79			* header[0] emphasis (1), muse(1), reserved(1), frame number(5)
80			* header[1] quant (2), freq(2), reserved(1), channels(3)
81			* header[2] dynamic range control (0x80 = off)
82			*/
83
84			/* Discard potentially existing leftover samples from old channel layout */
85		4	s->extra_sample_count = 0;
86
87			/* get the sample depth and derive the sample format from it */
88		4	avctx->bits_per_coded_sample = 16 + (header[1] >> 6 & 3) * 4;
89	✗✓	4	if (avctx->bits_per_coded_sample == 28) {
90			av_log(avctx, AV_LOG_ERROR,
91			"PCM DVD unsupported sample depth %i\n",
92			avctx->bits_per_coded_sample);
93			return AVERROR_INVALIDDATA;
94			}
95		8	avctx->sample_fmt = avctx->bits_per_coded_sample == 16 ? AV_SAMPLE_FMT_S16
96	✓✓	4	: AV_SAMPLE_FMT_S32;
97		4	avctx->bits_per_raw_sample = avctx->bits_per_coded_sample;
98
99			/* get the sample rate */
100		4	avctx->sample_rate = frequencies[header[1] >> 4 & 3];
101
102			/* get the number of channels */
103		4	avctx->channels = 1 + (header[1] & 7);
104			/* calculate the bitrate */
105		4	avctx->bit_rate = avctx->channels *
106		4	avctx->sample_rate *
107		4	avctx->bits_per_coded_sample;
108
109			/* 4 samples form a group in 20/24-bit PCM on DVD Video.
110			* A block is formed by the number of groups that are
111			* needed to complete a set of samples for each channel. */
112	✓✓	4	if (avctx->bits_per_coded_sample == 16) {
113		2	s->samples_per_block = 1;
114		2	s->block_size = avctx->channels * 2;
115			} else {
116	✓✗✗	2	switch (avctx->channels) {
117		2	case 1:
118			case 2:
119			case 4:
120			/* one group has all the samples needed */
121		2	s->block_size = 4 * avctx->bits_per_coded_sample / 8;
122		2	s->samples_per_block = 4 / avctx->channels;
123		2	s->groups_per_block = 1;
124		2	break;
125			case 8:
126			/* two groups have all the samples needed */
127			s->block_size = 8 * avctx->bits_per_coded_sample / 8;
128			s->samples_per_block = 1;
129			s->groups_per_block = 2;
130			break;
131			default:
132			/* need avctx->channels groups */
133			s->block_size = 4 * avctx->channels *
134			avctx->bits_per_coded_sample / 8;
135			s->samples_per_block = 4;
136			s->groups_per_block = avctx->channels;
137			break;
138			}
139			}
140
141		4	if (avctx->debug & FF_DEBUG_PICT_INFO)
142			ff_dlog(avctx,
143			"pcm_dvd_parse_header: %d channels, %d bits per sample, %d Hz, %"PRId64" bit/s\n",
144			avctx->channels, avctx->bits_per_coded_sample,
145			avctx->sample_rate, avctx->bit_rate);
146
147		4	s->last_header = header_int;
148
149		4	return 0;
150			}
151
152		126	static void pcm_dvd_decode_samples(AVCodecContext avctx, const uint8_t *src,
153			void *dst, int blocks)
154			{
155		126	PCMDVDContext *s = avctx->priv_data;
156		126	int16_t *dst16 = dst;
157		126	int32_t *dst32 = dst;
158			GetByteContext gb;
159			int i;
160			uint8_t t;
161
162		126	bytestream2_init(&gb, src, blocks * s->block_size);
163	✓✗✓✗	126	switch (avctx->bits_per_coded_sample) {
164		2	case 16: {
165			#if HAVE_BIGENDIAN
166			bytestream2_get_buffer(&gb, dst16, blocks * s->block_size);
167			dst16 += blocks * s->block_size / 2;
168			#else
169		2	int samples = blocks * avctx->channels;
170			do {
171		2002	*dst16++ = bytestream2_get_be16u(&gb);
172	✓✓	2002	} while (--samples);
173			#endif
174		2	return dst16;
175			}
176			case 20:
177			if (avctx->channels == 1) {
178			do {
179			for (i = 2; i; i--) {
180			dst32[0] = bytestream2_get_be16u(&gb) << 16;
181			dst32[1] = bytestream2_get_be16u(&gb) << 16;
182			t = bytestream2_get_byteu(&gb);
183			*dst32++ += (t & 0xf0) << 8;
184			*dst32++ += (t & 0x0f) << 12;
185			}
186			} while (--blocks);
187			} else {
188			do {
189			for (i = s->groups_per_block; i; i--) {
190			dst32[0] = bytestream2_get_be16u(&gb) << 16;
191			dst32[1] = bytestream2_get_be16u(&gb) << 16;
192			dst32[2] = bytestream2_get_be16u(&gb) << 16;
193			dst32[3] = bytestream2_get_be16u(&gb) << 16;
194			t = bytestream2_get_byteu(&gb);
195			*dst32++ += (t & 0xf0) << 8;
196			*dst32++ += (t & 0x0f) << 12;
197			t = bytestream2_get_byteu(&gb);
198			*dst32++ += (t & 0xf0) << 8;
199			*dst32++ += (t & 0x0f) << 12;
200			}
201			} while (--blocks);
202			}
203			return dst32;
204		124	case 24:
205	✗✓	124	if (avctx->channels == 1) {
206			do {
207			for (i = 2; i; i--) {
208			dst32[0] = bytestream2_get_be16u(&gb) << 16;
209			dst32[1] = bytestream2_get_be16u(&gb) << 16;
210			*dst32++ += bytestream2_get_byteu(&gb) << 8;
211			*dst32++ += bytestream2_get_byteu(&gb) << 8;
212			}
213			} while (--blocks);
214			} else {
215			do {
216	✓✓	41416	for (i = s->groups_per_block; i; i--) {
217		20708	dst32[0] = bytestream2_get_be16u(&gb) << 16;
218		20708	dst32[1] = bytestream2_get_be16u(&gb) << 16;
219		20708	dst32[2] = bytestream2_get_be16u(&gb) << 16;
220		20708	dst32[3] = bytestream2_get_be16u(&gb) << 16;
221		20708	*dst32++ += bytestream2_get_byteu(&gb) << 8;
222		20708	*dst32++ += bytestream2_get_byteu(&gb) << 8;
223		20708	*dst32++ += bytestream2_get_byteu(&gb) << 8;
224		20708	*dst32++ += bytestream2_get_byteu(&gb) << 8;
225			}
226	✓✓	20708	} while (--blocks);
227			}
228		124	return dst32;
229			default:
230			return NULL;
231			}
232			}
233
234		126	static int pcm_dvd_decode_frame(AVCodecContext avctx, void data,
235			int got_frame_ptr, AVPacket avpkt)
236			{
237		126	AVFrame *frame = data;
238		126	const uint8_t *src = avpkt->data;
239		126	int buf_size = avpkt->size;
240		126	PCMDVDContext *s = avctx->priv_data;
241			int retval;
242			int blocks;
243			void *dst;
244
245	✗✓	126	if (buf_size < 3) {
246			av_log(avctx, AV_LOG_ERROR, "PCM packet too small\n");
247			return AVERROR_INVALIDDATA;
248			}
249
250	✗✓	126	if ((retval = pcm_dvd_parse_header(avctx, src)))
251			return retval;
252	✓✓✗✓	126	if (s->last_block_size && s->last_block_size != s->block_size) {
253			av_log(avctx, AV_LOG_WARNING, "block_size has changed %d != %d\n", s->last_block_size, s->block_size);
254			s->extra_sample_count = 0;
255			}
256		126	s->last_block_size = s->block_size;
257		126	src += 3;
258		126	buf_size -= 3;
259
260		126	blocks = (buf_size + s->extra_sample_count) / s->block_size;
261
262			/* get output buffer */
263		126	frame->nb_samples = blocks * s->samples_per_block;
264	✗✓	126	if ((retval = ff_get_buffer(avctx, frame, 0)) < 0)
265			return retval;
266		126	dst = frame->data[0];
267
268			/* consume leftover samples from last packet */
269	✗✓	126	if (s->extra_sample_count) {
270			int missing_samples = s->block_size - s->extra_sample_count;
271			if (buf_size >= missing_samples) {
272			memcpy(s->extra_samples + s->extra_sample_count, src,
273			missing_samples);
274			dst = pcm_dvd_decode_samples(avctx, s->extra_samples, dst, 1);
275			src += missing_samples;
276			buf_size -= missing_samples;
277			s->extra_sample_count = 0;
278			blocks--;
279			} else {
280			/* new packet still doesn't have enough samples */
281			memcpy(s->extra_samples + s->extra_sample_count, src, buf_size);
282			s->extra_sample_count += buf_size;
283			return avpkt->size;
284			}
285			}
286
287			/* decode remaining complete samples */
288	✓✗	126	if (blocks) {
289		126	pcm_dvd_decode_samples(avctx, src, dst, blocks);
290		126	buf_size -= blocks * s->block_size;
291			}
292
293			/* store leftover samples */
294	✗✓	126	if (buf_size) {
295			src += blocks * s->block_size;
296			memcpy(s->extra_samples, src, buf_size);
297			s->extra_sample_count = buf_size;
298			}
299
300		126	*got_frame_ptr = 1;
301
302		126	return avpkt->size;
303			}
304
305			AVCodec ff_pcm_dvd_decoder = {
306			.name = "pcm_dvd",
307			.long_name = NULL_IF_CONFIG_SMALL("PCM signed 16\|20\|24-bit big-endian for DVD media"),
308			.type = AVMEDIA_TYPE_AUDIO,
309			.id = AV_CODEC_ID_PCM_DVD,
310			.priv_data_size = sizeof(PCMDVDContext),
311			.init = pcm_dvd_decode_init,
312			.decode = pcm_dvd_decode_frame,
313			.close = pcm_dvd_decode_uninit,
314			.capabilities = AV_CODEC_CAP_DR1,
315			.sample_fmts = (const enum AVSampleFormat[]) {
316			AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE
317			}
318			};