pcm-mpeg.c
Go to the documentation of this file.
1 /*
2  * LPCM codecs for PCM formats found in MPEG streams
3  * Copyright (c) 2009 Christian Schmidt
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "internal.h"
31 
32 /*
33  * Channel Mapping according to
34  * Blu-ray Disc Read-Only Format Version 1
35  * Part 3: Audio Visual Basic Specifications
36  * mono M1 X
37  * stereo L R
38  * 3/0 L R C X
39  * 2/1 L R S X
40  * 3/1 L R C S
41  * 2/2 L R LS RS
42  * 3/2 L R C LS RS X
43  * 3/2+lfe L R C LS RS lfe
44  * 3/4 L R C LS Rls Rrs RS X
45  * 3/4+lfe L R C LS Rls Rrs RS lfe
46  */
47 
54  const uint8_t *header)
55 {
56  static const uint8_t bits_per_samples[4] = { 0, 16, 20, 24 };
57  static const uint32_t channel_layouts[16] = {
61  };
62  static const uint8_t channels[16] = {
63  0, 1, 0, 2, 3, 3, 4, 4, 5, 6, 7, 8, 0, 0, 0, 0
64  };
65  uint8_t channel_layout = header[2] >> 4;
66 
67  if (avctx->debug & FF_DEBUG_PICT_INFO)
68  av_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) {
74  av_log(avctx, AV_LOG_ERROR, "reserved sample depth (0)\n");
75  return -1;
76  }
77  avctx->sample_fmt = avctx->bits_per_coded_sample == 16 ? AV_SAMPLE_FMT_S16 :
80 
81  /* get the sample rate. Not all values are used. */
82  switch (header[2] & 0x0f) {
83  case 1:
84  avctx->sample_rate = 48000;
85  break;
86  case 4:
87  avctx->sample_rate = 96000;
88  break;
89  case 5:
90  avctx->sample_rate = 192000;
91  break;
92  default:
93  avctx->sample_rate = 0;
94  av_log(avctx, AV_LOG_ERROR, "reserved sample rate (%d)\n",
95  header[2] & 0x0f);
96  return -1;
97  }
98 
99  /*
100  * get the channel number (and mapping). Not all values are used.
101  * It must be noted that the number of channels in the MPEG stream can
102  * differ from the actual meaningful number, e.g. mono audio still has two
103  * channels, one being empty.
104  */
105  avctx->channel_layout = channel_layouts[channel_layout];
106  avctx->channels = channels[channel_layout];
107  if (!avctx->channels) {
108  av_log(avctx, AV_LOG_ERROR, "reserved channel configuration (%d)\n",
109  channel_layout);
110  return -1;
111  }
112 
113  avctx->bit_rate = FFALIGN(avctx->channels, 2) * avctx->sample_rate *
114  avctx->bits_per_coded_sample;
115 
116  if (avctx->debug & FF_DEBUG_PICT_INFO)
117  av_dlog(avctx,
118  "pcm_bluray_parse_header: %d channels, %d bits per sample, %d Hz, %d bit/s\n",
119  avctx->channels, avctx->bits_per_coded_sample,
120  avctx->sample_rate, avctx->bit_rate);
121  return 0;
122 }
123 
124 typedef struct PCMBRDecode {
126 } PCMBRDecode;
127 
129 {
130  PCMBRDecode *s = avctx->priv_data;
131 
133  avctx->coded_frame = &s->frame;
134 
135  return 0;
136 }
137 
138 static int pcm_bluray_decode_frame(AVCodecContext *avctx, void *data,
139  int *got_frame_ptr, AVPacket *avpkt)
140 {
141  const uint8_t *src = avpkt->data;
142  int buf_size = avpkt->size;
143  PCMBRDecode *s = avctx->priv_data;
144  GetByteContext gb;
145  int num_source_channels, channel, retval;
146  int sample_size, samples;
147  int16_t *dst16;
148  int32_t *dst32;
149 
150  if (buf_size < 4) {
151  av_log(avctx, AV_LOG_ERROR, "PCM packet too small\n");
152  return -1;
153  }
154 
155  if (pcm_bluray_parse_header(avctx, src))
156  return -1;
157  src += 4;
158  buf_size -= 4;
159 
160  bytestream2_init(&gb, src, buf_size);
161 
162  /* There's always an even number of channels in the source */
163  num_source_channels = FFALIGN(avctx->channels, 2);
164  sample_size = (num_source_channels * (avctx->sample_fmt == AV_SAMPLE_FMT_S16 ? 16 : 24)) >> 3;
165  samples = buf_size / sample_size;
166 
167  /* get output buffer */
168  s->frame.nb_samples = samples;
169  if ((retval = ff_get_buffer(avctx, &s->frame)) < 0) {
170  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
171  return retval;
172  }
173  dst16 = (int16_t *)s->frame.data[0];
174  dst32 = (int32_t *)s->frame.data[0];
175 
176  if (samples) {
177  switch (avctx->channel_layout) {
178  /* cases with same number of source and coded channels */
179  case AV_CH_LAYOUT_STEREO:
181  case AV_CH_LAYOUT_2_2:
182  samples *= num_source_channels;
183  if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
184 #if HAVE_BIGENDIAN
185  bytestream2_get_buffer(&gb, dst16, buf_size);
186 #else
187  do {
188  *dst16++ = bytestream2_get_be16u(&gb);
189  } while (--samples);
190 #endif
191  } else {
192  do {
193  *dst32++ = bytestream2_get_be24u(&gb) << 8;
194  } while (--samples);
195  }
196  break;
197  /* cases where number of source channels = coded channels + 1 */
198  case AV_CH_LAYOUT_MONO:
200  case AV_CH_LAYOUT_2_1:
202  if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
203  do {
204 #if HAVE_BIGENDIAN
205  bytestream2_get_buffer(&gb, dst16, avctx->channels * 2);
206  dst16 += avctx->channels;
207 #else
208  channel = avctx->channels;
209  do {
210  *dst16++ = bytestream2_get_be16u(&gb);
211  } while (--channel);
212 #endif
213  bytestream2_skip(&gb, 2);
214  } while (--samples);
215  } else {
216  do {
217  channel = avctx->channels;
218  do {
219  *dst32++ = bytestream2_get_be24u(&gb) << 8;
220  } while (--channel);
221  bytestream2_skip(&gb, 3);
222  } while (--samples);
223  }
224  break;
225  /* remapping: L, R, C, LBack, RBack, LF */
227  if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
228  do {
229  dst16[0] = bytestream2_get_be16u(&gb);
230  dst16[1] = bytestream2_get_be16u(&gb);
231  dst16[2] = bytestream2_get_be16u(&gb);
232  dst16[4] = bytestream2_get_be16u(&gb);
233  dst16[5] = bytestream2_get_be16u(&gb);
234  dst16[3] = bytestream2_get_be16u(&gb);
235  dst16 += 6;
236  } while (--samples);
237  } else {
238  do {
239  dst32[0] = bytestream2_get_be24u(&gb) << 8;
240  dst32[1] = bytestream2_get_be24u(&gb) << 8;
241  dst32[2] = bytestream2_get_be24u(&gb) << 8;
242  dst32[4] = bytestream2_get_be24u(&gb) << 8;
243  dst32[5] = bytestream2_get_be24u(&gb) << 8;
244  dst32[3] = bytestream2_get_be24u(&gb) << 8;
245  dst32 += 6;
246  } while (--samples);
247  }
248  break;
249  /* remapping: L, R, C, LSide, LBack, RBack, RSide, <unused> */
251  if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
252  do {
253  dst16[0] = bytestream2_get_be16u(&gb);
254  dst16[1] = bytestream2_get_be16u(&gb);
255  dst16[2] = bytestream2_get_be16u(&gb);
256  dst16[5] = bytestream2_get_be16u(&gb);
257  dst16[3] = bytestream2_get_be16u(&gb);
258  dst16[4] = bytestream2_get_be16u(&gb);
259  dst16[6] = bytestream2_get_be16u(&gb);
260  dst16 += 7;
261  bytestream2_skip(&gb, 2);
262  } while (--samples);
263  } else {
264  do {
265  dst32[0] = bytestream2_get_be24u(&gb) << 8;
266  dst32[1] = bytestream2_get_be24u(&gb) << 8;
267  dst32[2] = bytestream2_get_be24u(&gb) << 8;
268  dst32[5] = bytestream2_get_be24u(&gb) << 8;
269  dst32[3] = bytestream2_get_be24u(&gb) << 8;
270  dst32[4] = bytestream2_get_be24u(&gb) << 8;
271  dst32[6] = bytestream2_get_be24u(&gb) << 8;
272  dst32 += 7;
273  bytestream2_skip(&gb, 3);
274  } while (--samples);
275  }
276  break;
277  /* remapping: L, R, C, LSide, LBack, RBack, RSide, LF */
279  if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
280  do {
281  dst16[0] = bytestream2_get_be16u(&gb);
282  dst16[1] = bytestream2_get_be16u(&gb);
283  dst16[2] = bytestream2_get_be16u(&gb);
284  dst16[6] = bytestream2_get_be16u(&gb);
285  dst16[4] = bytestream2_get_be16u(&gb);
286  dst16[5] = bytestream2_get_be16u(&gb);
287  dst16[7] = bytestream2_get_be16u(&gb);
288  dst16[3] = bytestream2_get_be16u(&gb);
289  dst16 += 8;
290  } while (--samples);
291  } else {
292  do {
293  dst32[0] = bytestream2_get_be24u(&gb) << 8;
294  dst32[1] = bytestream2_get_be24u(&gb) << 8;
295  dst32[2] = bytestream2_get_be24u(&gb) << 8;
296  dst32[6] = bytestream2_get_be24u(&gb) << 8;
297  dst32[4] = bytestream2_get_be24u(&gb) << 8;
298  dst32[5] = bytestream2_get_be24u(&gb) << 8;
299  dst32[7] = bytestream2_get_be24u(&gb) << 8;
300  dst32[3] = bytestream2_get_be24u(&gb) << 8;
301  dst32 += 8;
302  } while (--samples);
303  }
304  break;
305  }
306  }
307 
308  *got_frame_ptr = 1;
309  *(AVFrame *)data = s->frame;
310 
311  retval = bytestream2_tell(&gb);
312  if (avctx->debug & FF_DEBUG_BITSTREAM)
313  av_dlog(avctx, "pcm_bluray_decode_frame: decoded %d -> %d bytes\n",
314  retval, buf_size);
315  return retval + 4;
316 }
317 
319  .name = "pcm_bluray",
320  .type = AVMEDIA_TYPE_AUDIO,
322  .priv_data_size = sizeof(PCMBRDecode),
325  .capabilities = CODEC_CAP_DR1,
326  .sample_fmts = (const enum AVSampleFormat[]){
328  },
329  .long_name = NULL_IF_CONFIG_SMALL("PCM signed 16|20|24-bit big-endian for Blu-ray media"),
330 };
#define AV_CH_LAYOUT_7POINT1
static int pcm_bluray_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: pcm-mpeg.c:138
static int16_t * samples
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
#define AV_CH_LAYOUT_SURROUND
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
int size
Definition: avcodec.h:916
static av_cold int pcm_bluray_decode_init(AVCodecContext *avctx)
Definition: pcm-mpeg.c:128
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
#define AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_7POINT0
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2711
#define AV_CH_LAYOUT_STEREO
signed 16 bits
Definition: samplefmt.h:52
AVCodec.
Definition: avcodec.h:2960
#define AV_CH_LAYOUT_5POINT0
AVFrame frame
Definition: pcm-mpeg.c:125
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
uint8_t
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2704
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
#define AV_CH_LAYOUT_5POINT1
AVCodec ff_pcm_bluray_decoder
Definition: pcm-mpeg.c:318
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:159
sample_fmts
Definition: avconv_filter.c:63
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:258
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2165
#define AV_CH_LAYOUT_2_1
#define AV_CH_LAYOUT_2_2
signed 32 bits
Definition: samplefmt.h:53
int bit_rate
the average bitrate
Definition: avcodec.h:1404
audio channel layout utility functions
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
int32_t
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:183
external API header
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
int sample_rate
samples per second
Definition: avcodec.h:2104
int debug
debug
Definition: avcodec.h:2568
main external API structure.
Definition: avcodec.h:1339
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:602
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
static int pcm_bluray_parse_header(AVCodecContext *avctx, const uint8_t *header)
Parse the header of a LPCM frame read from a MPEG-TS stream.
Definition: pcm-mpeg.c:53
common internal api header.
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
void * priv_data
Definition: avcodec.h:1382
struct PCMBRDecode PCMBRDecode
int channels
number of audio channels
Definition: avcodec.h:2105
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:898
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042