FFmpeg  4.4
mpc.c
Go to the documentation of this file.
1 /*
2  * Musepack demuxer
3  * Copyright (c) 2006 Konstantin Shishkov
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 
23 
24 #include "avformat.h"
25 #include "internal.h"
26 #include "apetag.h"
27 #include "id3v1.h"
28 #include "libavutil/dict.h"
29 
30 #define MPC_FRAMESIZE 1152
31 #define DELAY_FRAMES 32
32 
33 static const int mpc_rate[4] = { 44100, 48000, 37800, 32000 };
34 typedef struct MPCFrame {
35  int64_t pos;
36  int size, skip;
37 }MPCFrame;
38 
39 typedef struct MPCContext {
40  int ver;
41  uint32_t curframe, lastframe;
42  uint32_t fcount;
44  int curbits;
46 } MPCContext;
47 
48 static int mpc_probe(const AVProbeData *p)
49 {
50  const uint8_t *d = p->buf;
51  if (d[0] == 'M' && d[1] == 'P' && d[2] == '+' && (d[3] == 0x17 || d[3] == 0x7))
52  return AVPROBE_SCORE_MAX;
53  return 0;
54 }
55 
57 {
58  MPCContext *c = s->priv_data;
59  AVStream *st;
60  int ret;
61 
62  if(avio_rl24(s->pb) != MKTAG('M', 'P', '+', 0)){
63  av_log(s, AV_LOG_ERROR, "Not a Musepack file\n");
64  return AVERROR_INVALIDDATA;
65  }
66  c->ver = avio_r8(s->pb);
67  if(c->ver != 0x07 && c->ver != 0x17){
68  av_log(s, AV_LOG_ERROR, "Can demux Musepack SV7, got version %02X\n", c->ver);
69  return AVERROR_INVALIDDATA;
70  }
71  c->fcount = avio_rl32(s->pb);
72  if((int64_t)c->fcount * sizeof(MPCFrame) >= UINT_MAX){
73  av_log(s, AV_LOG_ERROR, "Too many frames, seeking is not possible\n");
74  return AVERROR_INVALIDDATA;
75  }
76  c->curframe = 0;
77  c->lastframe = -1;
78  c->curbits = 8;
79  c->frames_noted = 0;
80 
81  st = avformat_new_stream(s, NULL);
82  if (!st)
83  return AVERROR(ENOMEM);
84 
85  if (c->fcount) {
86  c->frames = av_malloc(c->fcount * sizeof(MPCFrame));
87  if (!c->frames) {
88  av_log(s, AV_LOG_ERROR, "Cannot allocate seektable\n");
89  return AVERROR(ENOMEM);
90  }
91  st->priv_data = c->frames;
92  } else {
93  av_log(s, AV_LOG_WARNING, "Container reports no frames\n");
94  }
95 
98  st->codecpar->channels = 2;
101 
102  if ((ret = ff_get_extradata(s, st->codecpar, s->pb, 16)) < 0)
103  return ret;
104  st->codecpar->sample_rate = mpc_rate[st->codecpar->extradata[2] & 3];
106  /* scan for seekpoints */
107  st->start_time = 0;
108  st->duration = c->fcount;
109 
110  /* try to read APE tags */
111  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
112  int64_t pos = avio_tell(s->pb);
114  if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
115  ff_id3v1_read(s);
116  avio_seek(s->pb, pos, SEEK_SET);
117  }
118 
119  return 0;
120 }
121 
123 {
124  MPCContext *c = s->priv_data;
125  int ret, size, size2, curbits, cur = c->curframe;
126  unsigned tmp;
127  int64_t pos;
128 
129  if (c->curframe >= c->fcount && c->fcount)
130  return AVERROR_EOF;
131 
132  if(c->curframe != c->lastframe + 1){
133  avio_seek(s->pb, c->frames[c->curframe].pos, SEEK_SET);
134  c->curbits = c->frames[c->curframe].skip;
135  }
136  c->lastframe = c->curframe;
137  c->curframe++;
138  curbits = c->curbits;
139  pos = avio_tell(s->pb);
140  tmp = avio_rl32(s->pb);
141  if(curbits <= 12){
142  size2 = (tmp >> (12 - curbits)) & 0xFFFFF;
143  }else{
144  size2 = (tmp << (curbits - 12) | avio_rl32(s->pb) >> (44 - curbits)) & 0xFFFFF;
145  }
146  curbits += 20;
147  avio_seek(s->pb, pos, SEEK_SET);
148 
149  size = ((size2 + curbits + 31) & ~31) >> 3;
150  if(cur == c->frames_noted && c->fcount){
151  c->frames[cur].pos = pos;
152  c->frames[cur].size = size;
153  c->frames[cur].skip = curbits - 20;
154  av_add_index_entry(s->streams[0], cur, cur, size, 0, AVINDEX_KEYFRAME);
155  c->frames_noted++;
156  }
157  c->curbits = (curbits + size2) & 0x1F;
158 
159  if ((ret = av_new_packet(pkt, size + 4)) < 0)
160  return ret;
161 
162  pkt->data[0] = curbits;
163  pkt->data[1] = (c->curframe > c->fcount) && c->fcount;
164  pkt->data[2] = 0;
165  pkt->data[3] = 0;
166 
167  pkt->stream_index = 0;
168  pkt->pts = cur;
169  ret = avio_read(s->pb, pkt->data + 4, size);
170  if(c->curbits)
171  avio_seek(s->pb, -4, SEEK_CUR);
172  if(ret < size){
173  return ret < 0 ? ret : AVERROR(EIO);
174  }
175  pkt->size = ret + 4;
176 
177  return 0;
178 }
179 
180 /**
181  * Seek to the given position
182  * If position is unknown but is within the limits of file
183  * then packets are skipped unless desired position is reached
184  *
185  * Also this function makes use of the fact that timestamp == frameno
186  */
187 static int mpc_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
188 {
189  AVStream *st = s->streams[stream_index];
190  MPCContext *c = s->priv_data;
191  AVPacket pkt1, *pkt = &pkt1;
192  int ret;
193  int index = av_index_search_timestamp(st, FFMAX(timestamp - DELAY_FRAMES, 0), flags);
194  uint32_t lastframe;
195 
196  /* if found, seek there */
197  if (index >= 0 && st->index_entries[st->nb_index_entries-1].timestamp >= timestamp - DELAY_FRAMES){
198  c->curframe = st->index_entries[index].pos;
199  return 0;
200  }
201  /* if timestamp is out of bounds, return error */
202  if(timestamp < 0 || timestamp >= c->fcount)
203  return -1;
204  timestamp -= DELAY_FRAMES;
205  /* seek to the furthest known position and read packets until
206  we reach desired position */
207  lastframe = c->curframe;
208  if(c->frames_noted) c->curframe = c->frames_noted - 1;
209  while(c->curframe < timestamp){
210  ret = av_read_frame(s, pkt);
211  if (ret < 0){
212  c->curframe = lastframe;
213  return ret;
214  }
216  }
217  return 0;
218 }
219 
220 
222  .name = "mpc",
223  .long_name = NULL_IF_CONFIG_SMALL("Musepack"),
224  .priv_data_size = sizeof(MPCContext),
229  .extensions = "mpc",
230 };
int64_t ff_ape_parse_tag(AVFormatContext *s)
Read and parse an APE tag.
Definition: apetag.c:118
uint8_t
Main libavformat public API header.
#define AVINDEX_KEYFRAME
Definition: avformat.h:811
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:750
unsigned int avio_rl24(AVIOContext *s)
Definition: aviobuf.c:742
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:624
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define s(width, name)
Definition: cbs_vp9.c:257
audio channel layout utility functions
#define MKTAG(a, b, c, d)
Definition: common.h:478
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
Public dictionary API.
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
#define AV_CH_LAYOUT_STEREO
@ AV_CODEC_ID_MUSEPACK7
Definition: codec_id.h:452
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4505
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1739
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:2011
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2128
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:70
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
int index
Definition: gxfenc.c:89
void ff_id3v1_read(AVFormatContext *s)
Read an ID3v1 tag.
Definition: id3v1.c:279
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4941
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:3330
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
static int mpc_probe(const AVProbeData *p)
Definition: mpc.c:48
#define MPC_FRAMESIZE
Definition: mpc.c:30
static int mpc_read_header(AVFormatContext *s)
Definition: mpc.c:56
static int mpc_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the given position If position is unknown but is within the limits of file then packets are s...
Definition: mpc.c:187
static int mpc_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpc.c:122
AVInputFormat ff_mpc_demuxer
Definition: mpc.c:221
#define DELAY_FRAMES
Definition: mpc.c:31
static const int mpc_rate[4]
Definition: mpc.c:33
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
unsigned int pos
Definition: spdifenc.c:412
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
int channels
Audio only.
Definition: codec_par.h:166
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
Format I/O context.
Definition: avformat.h:1232
int64_t pos
Definition: avformat.h:804
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:805
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
void * priv_data
Definition: avformat.h:888
int nb_index_entries
Definition: avformat.h:1092
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:912
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1090
Definition: mpc.h:53
uint32_t curframe
Definition: mpc.c:41
int curbits
Definition: mpc.c:44
MPCFrame * frames
Definition: mpc.c:43
uint32_t fcount
Definition: mpc.c:42
int frames_noted
Definition: mpc.c:45
int ver
Definition: mpc.c:40
uint32_t lastframe
Definition: mpc.c:41
Definition: mpc.c:34
int size
Definition: mpc.c:36
int skip
Definition: mpc.c:36
int64_t pos
Definition: mpc.c:35
#define av_malloc(s)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
AVPacket * pkt
Definition: movenc.c:59
int size
static double c[64]