LCOV - code coverage report
Current view: top level - libavformat - wavdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 286 495 57.8 %
Date: 2017-12-14 01:15:32 Functions: 13 16 81.2 %

          Line data    Source code
       1             : /*
       2             :  * WAV demuxer
       3             :  * Copyright (c) 2001, 2002 Fabrice Bellard
       4             :  *
       5             :  * Sony Wave64 demuxer
       6             :  * RF64 demuxer
       7             :  * Copyright (c) 2009 Daniel Verkamp
       8             :  *
       9             :  * This file is part of FFmpeg.
      10             :  *
      11             :  * FFmpeg is free software; you can redistribute it and/or
      12             :  * modify it under the terms of the GNU Lesser General Public
      13             :  * License as published by the Free Software Foundation; either
      14             :  * version 2.1 of the License, or (at your option) any later version.
      15             :  *
      16             :  * FFmpeg is distributed in the hope that it will be useful,
      17             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      18             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      19             :  * Lesser General Public License for more details.
      20             :  *
      21             :  * You should have received a copy of the GNU Lesser General Public
      22             :  * License along with FFmpeg; if not, write to the Free Software
      23             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      24             :  */
      25             : 
      26             : #include <stdint.h>
      27             : 
      28             : #include "libavutil/avassert.h"
      29             : #include "libavutil/dict.h"
      30             : #include "libavutil/intreadwrite.h"
      31             : #include "libavutil/log.h"
      32             : #include "libavutil/mathematics.h"
      33             : #include "libavutil/opt.h"
      34             : #include "avformat.h"
      35             : #include "avio.h"
      36             : #include "avio_internal.h"
      37             : #include "internal.h"
      38             : #include "metadata.h"
      39             : #include "pcm.h"
      40             : #include "riff.h"
      41             : #include "w64.h"
      42             : #include "spdif.h"
      43             : 
      44             : typedef struct WAVDemuxContext {
      45             :     const AVClass *class;
      46             :     int64_t data_end;
      47             :     int w64;
      48             :     int64_t smv_data_ofs;
      49             :     int smv_block_size;
      50             :     int smv_frames_per_jpeg;
      51             :     int smv_block;
      52             :     int smv_last_stream;
      53             :     int smv_eof;
      54             :     int audio_eof;
      55             :     int ignore_length;
      56             :     int spdif;
      57             :     int smv_cur_pt;
      58             :     int smv_given_first;
      59             :     int unaligned; // e.g. if an odd number of bytes ID3 tag was prepended
      60             :     int rifx; // RIFX: integer byte order for parameters is big endian
      61             : } WAVDemuxContext;
      62             : 
      63         508 : static void set_spdif(AVFormatContext *s, WAVDemuxContext *wav)
      64             : {
      65         508 :     if (CONFIG_SPDIF_DEMUXER && s->streams[0]->codecpar->codec_tag == 1) {
      66             :         enum AVCodecID codec;
      67         474 :         int len = 1<<16;
      68         474 :         int ret = ffio_ensure_seekback(s->pb, len);
      69             : 
      70         474 :         if (ret >= 0) {
      71         474 :             uint8_t *buf = av_malloc(len);
      72         474 :             if (!buf) {
      73           0 :                 ret = AVERROR(ENOMEM);
      74             :             } else {
      75         474 :                 int64_t pos = avio_tell(s->pb);
      76         474 :                 len = ret = avio_read(s->pb, buf, len);
      77         474 :                 if (len >= 0) {
      78         474 :                     ret = ff_spdif_probe(buf, len, &codec);
      79         474 :                     if (ret > AVPROBE_SCORE_EXTENSION) {
      80           1 :                         s->streams[0]->codecpar->codec_id = codec;
      81           1 :                         wav->spdif = 1;
      82             :                     }
      83             :                 }
      84         474 :                 avio_seek(s->pb, pos, SEEK_SET);
      85         474 :                 av_free(buf);
      86             :             }
      87             :         }
      88             : 
      89         474 :         if (ret < 0)
      90           0 :             av_log(s, AV_LOG_WARNING, "Cannot check for SPDIF\n");
      91             :     }
      92         508 : }
      93             : 
      94             : #if CONFIG_WAV_DEMUXER
      95             : 
      96        1354 : static int64_t next_tag(AVIOContext *pb, uint32_t *tag, int big_endian)
      97             : {
      98        1354 :     *tag = avio_rl32(pb);
      99        1354 :     if (!big_endian) {
     100        1354 :         return avio_rl32(pb);
     101             :     } else {
     102           0 :         return avio_rb32(pb);
     103             :     }
     104             : }
     105             : 
     106             : /* RIFF chunks are always at even offsets relative to where they start. */
     107         848 : static int64_t wav_seek_tag(WAVDemuxContext * wav, AVIOContext *s, int64_t offset, int whence)
     108             : {
     109         848 :     offset += offset < INT64_MAX && offset + wav->unaligned & 1;
     110             : 
     111         848 :     return avio_seek(s, offset, whence);
     112             : }
     113             : 
     114             : /* return the size of the found tag */
     115         651 : static int64_t find_tag(WAVDemuxContext * wav, AVIOContext *pb, uint32_t tag1)
     116             : {
     117             :     unsigned int tag;
     118             :     int64_t size;
     119             : 
     120             :     for (;;) {
     121         944 :         if (avio_feof(pb))
     122         358 :             return AVERROR_EOF;
     123         293 :         size = next_tag(pb, &tag, wav->rifx);
     124         293 :         if (tag == tag1)
     125           0 :             break;
     126         293 :         wav_seek_tag(wav, pb, size, SEEK_CUR);
     127             :     }
     128           0 :     return size;
     129             : }
     130             : 
     131        6130 : static int wav_probe(AVProbeData *p)
     132             : {
     133             :     /* check file header */
     134        6130 :     if (p->buf_size <= 32)
     135           0 :         return 0;
     136        6130 :     if (!memcmp(p->buf + 8, "WAVE", 4)) {
     137         459 :         if (!memcmp(p->buf, "RIFF", 4) || !memcmp(p->buf, "RIFX", 4))
     138             :             /* Since the ACT demuxer has a standard WAV header at the top of
     139             :              * its own, the returned score is decreased to avoid a probe
     140             :              * conflict between ACT and WAV. */
     141         459 :             return AVPROBE_SCORE_MAX - 1;
     142           0 :         else if (!memcmp(p->buf,      "RF64", 4) &&
     143           0 :                  !memcmp(p->buf + 12, "ds64", 4))
     144           0 :             return AVPROBE_SCORE_MAX;
     145             :     }
     146        5671 :     return 0;
     147             : }
     148             : 
     149         508 : static void handle_stream_probing(AVStream *st)
     150             : {
     151         508 :     if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
     152         461 :         st->request_probe = AVPROBE_SCORE_EXTENSION;
     153         461 :         st->probe_packets = FFMIN(st->probe_packets, 32);
     154             :     }
     155         508 : }
     156             : 
     157         506 : static int wav_parse_fmt_tag(AVFormatContext *s, int64_t size, AVStream **st)
     158             : {
     159         506 :     AVIOContext *pb = s->pb;
     160         506 :     WAVDemuxContext *wav = s->priv_data;
     161             :     int ret;
     162             : 
     163             :     /* parse fmt header */
     164         506 :     *st = avformat_new_stream(s, NULL);
     165         506 :     if (!*st)
     166           0 :         return AVERROR(ENOMEM);
     167             : 
     168         506 :     ret = ff_get_wav_header(s, pb, (*st)->codecpar, size, wav->rifx);
     169         506 :     if (ret < 0)
     170           0 :         return ret;
     171         506 :     handle_stream_probing(*st);
     172             : 
     173         506 :     (*st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;
     174             : 
     175         506 :     avpriv_set_pts_info(*st, 64, 1, (*st)->codecpar->sample_rate);
     176             : 
     177         506 :     return 0;
     178             : }
     179             : 
     180           0 : static int wav_parse_xma2_tag(AVFormatContext *s, int64_t size, AVStream **st)
     181             : {
     182           0 :     AVIOContext *pb = s->pb;
     183           0 :     int version, num_streams, i, channels = 0;
     184             : 
     185           0 :     if (size < 36)
     186           0 :         return AVERROR_INVALIDDATA;
     187             : 
     188           0 :     *st = avformat_new_stream(s, NULL);
     189           0 :     if (!*st)
     190           0 :         return AVERROR(ENOMEM);
     191             : 
     192           0 :     (*st)->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
     193           0 :     (*st)->codecpar->codec_id   = AV_CODEC_ID_XMA2;
     194           0 :     (*st)->need_parsing         = AVSTREAM_PARSE_FULL_RAW;
     195             : 
     196           0 :     version = avio_r8(pb);
     197           0 :     if (version != 3 && version != 4)
     198           0 :         return AVERROR_INVALIDDATA;
     199           0 :     num_streams = avio_r8(pb);
     200           0 :     if (size != (32 + ((version==3)?0:8) + 4*num_streams))
     201           0 :         return AVERROR_INVALIDDATA;
     202           0 :     avio_skip(pb, 10);
     203           0 :     (*st)->codecpar->sample_rate = avio_rb32(pb);
     204           0 :     if (version == 4)
     205           0 :         avio_skip(pb, 8);
     206           0 :     avio_skip(pb, 4);
     207           0 :     (*st)->duration = avio_rb32(pb);
     208           0 :     avio_skip(pb, 8);
     209             : 
     210           0 :     for (i = 0; i < num_streams; i++) {
     211           0 :         channels += avio_r8(pb);
     212           0 :         avio_skip(pb, 3);
     213             :     }
     214           0 :     (*st)->codecpar->channels = channels;
     215             : 
     216           0 :     if ((*st)->codecpar->channels <= 0 || (*st)->codecpar->sample_rate <= 0)
     217           0 :         return AVERROR_INVALIDDATA;
     218             : 
     219           0 :     avpriv_set_pts_info(*st, 64, 1, (*st)->codecpar->sample_rate);
     220             : 
     221           0 :     avio_seek(pb, -size, SEEK_CUR);
     222           0 :     av_freep(&(*st)->codecpar->extradata);
     223           0 :     if (ff_get_extradata(s, (*st)->codecpar, pb, size) < 0)
     224           0 :         return AVERROR(ENOMEM);
     225             : 
     226           0 :     return 0;
     227             : }
     228             : 
     229           0 : static inline int wav_parse_bext_string(AVFormatContext *s, const char *key,
     230             :                                         int length)
     231             : {
     232             :     char temp[257];
     233             :     int ret;
     234             : 
     235           0 :     av_assert0(length <= sizeof(temp));
     236           0 :     if ((ret = avio_read(s->pb, temp, length)) < 0)
     237           0 :         return ret;
     238             : 
     239           0 :     temp[length] = 0;
     240             : 
     241           0 :     if (strlen(temp))
     242           0 :         return av_dict_set(&s->metadata, key, temp, 0);
     243             : 
     244           0 :     return 0;
     245             : }
     246             : 
     247           0 : static int wav_parse_bext_tag(AVFormatContext *s, int64_t size)
     248             : {
     249             :     char temp[131], *coding_history;
     250             :     int ret, x;
     251             :     uint64_t time_reference;
     252           0 :     int64_t umid_parts[8], umid_mask = 0;
     253             : 
     254           0 :     if ((ret = wav_parse_bext_string(s, "description", 256)) < 0 ||
     255           0 :         (ret = wav_parse_bext_string(s, "originator", 32)) < 0 ||
     256           0 :         (ret = wav_parse_bext_string(s, "originator_reference", 32)) < 0 ||
     257           0 :         (ret = wav_parse_bext_string(s, "origination_date", 10)) < 0 ||
     258             :         (ret = wav_parse_bext_string(s, "origination_time", 8)) < 0)
     259           0 :         return ret;
     260             : 
     261           0 :     time_reference = avio_rl64(s->pb);
     262           0 :     snprintf(temp, sizeof(temp), "%"PRIu64, time_reference);
     263           0 :     if ((ret = av_dict_set(&s->metadata, "time_reference", temp, 0)) < 0)
     264           0 :         return ret;
     265             : 
     266             :     /* check if version is >= 1, in which case an UMID may be present */
     267           0 :     if (avio_rl16(s->pb) >= 1) {
     268           0 :         for (x = 0; x < 8; x++)
     269           0 :             umid_mask |= umid_parts[x] = avio_rb64(s->pb);
     270             : 
     271           0 :         if (umid_mask) {
     272             :             /* the string formatting below is per SMPTE 330M-2004 Annex C */
     273           0 :             if (umid_parts[4] == 0 && umid_parts[5] == 0 &&
     274           0 :                 umid_parts[6] == 0 && umid_parts[7] == 0) {
     275             :                 /* basic UMID */
     276           0 :                 snprintf(temp, sizeof(temp),
     277             :                          "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
     278             :                          umid_parts[0], umid_parts[1],
     279             :                          umid_parts[2], umid_parts[3]);
     280             :             } else {
     281             :                 /* extended UMID */
     282           0 :                 snprintf(temp, sizeof(temp),
     283             :                          "0x%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64
     284             :                          "%016"PRIX64"%016"PRIX64"%016"PRIX64"%016"PRIX64,
     285             :                          umid_parts[0], umid_parts[1],
     286             :                          umid_parts[2], umid_parts[3],
     287             :                          umid_parts[4], umid_parts[5],
     288             :                          umid_parts[6], umid_parts[7]);
     289             :             }
     290             : 
     291           0 :             if ((ret = av_dict_set(&s->metadata, "umid", temp, 0)) < 0)
     292           0 :                 return ret;
     293             :         }
     294             : 
     295           0 :         avio_skip(s->pb, 190);
     296             :     } else
     297           0 :         avio_skip(s->pb, 254);
     298             : 
     299           0 :     if (size > 602) {
     300             :         /* CodingHistory present */
     301           0 :         size -= 602;
     302             : 
     303           0 :         if (!(coding_history = av_malloc(size + 1)))
     304           0 :             return AVERROR(ENOMEM);
     305             : 
     306           0 :         if ((ret = avio_read(s->pb, coding_history, size)) < 0)
     307           0 :             return ret;
     308             : 
     309           0 :         coding_history[size] = 0;
     310           0 :         if ((ret = av_dict_set(&s->metadata, "coding_history", coding_history,
     311             :                                AV_DICT_DONT_STRDUP_VAL)) < 0)
     312           0 :             return ret;
     313             :     }
     314             : 
     315           0 :     return 0;
     316             : }
     317             : 
     318             : static const AVMetadataConv wav_metadata_conv[] = {
     319             :     { "description",      "comment"       },
     320             :     { "originator",       "encoded_by"    },
     321             :     { "origination_date", "date"          },
     322             :     { "origination_time", "creation_time" },
     323             :     { 0 },
     324             : };
     325             : 
     326             : /* wav input */
     327         506 : static int wav_read_header(AVFormatContext *s)
     328             : {
     329         506 :     int64_t size, av_uninit(data_size);
     330         506 :     int64_t sample_count = 0;
     331         506 :     int rf64 = 0;
     332             :     uint32_t tag;
     333         506 :     AVIOContext *pb      = s->pb;
     334         506 :     AVStream *st         = NULL;
     335         506 :     WAVDemuxContext *wav = s->priv_data;
     336         506 :     int ret, got_fmt = 0, got_xma2 = 0;
     337         506 :     int64_t next_tag_ofs, data_ofs = -1;
     338             : 
     339         506 :     wav->unaligned = avio_tell(s->pb) & 1;
     340             : 
     341         506 :     wav->smv_data_ofs = -1;
     342             : 
     343             :     /* read chunk ID */
     344         506 :     tag = avio_rl32(pb);
     345         506 :     switch (tag) {
     346         506 :     case MKTAG('R', 'I', 'F', 'F'):
     347         506 :         break;
     348           0 :     case MKTAG('R', 'I', 'F', 'X'):
     349           0 :         wav->rifx = 1;
     350           0 :         break;
     351           0 :     case MKTAG('R', 'F', '6', '4'):
     352           0 :         rf64 = 1;
     353           0 :         break;
     354           0 :     default:
     355           0 :         av_log(s, AV_LOG_ERROR, "invalid start code %s in RIFF header\n",
     356           0 :                av_fourcc2str(tag));
     357           0 :         return AVERROR_INVALIDDATA;
     358             :     }
     359             : 
     360             :     /* read chunk size */
     361         506 :     avio_rl32(pb);
     362             : 
     363             :     /* read format */
     364         506 :     if (avio_rl32(pb) != MKTAG('W', 'A', 'V', 'E')) {
     365           0 :         av_log(s, AV_LOG_ERROR, "invalid format in RIFF header\n");
     366           0 :         return AVERROR_INVALIDDATA;
     367             :     }
     368             : 
     369         506 :     if (rf64) {
     370           0 :         if (avio_rl32(pb) != MKTAG('d', 's', '6', '4'))
     371           0 :             return AVERROR_INVALIDDATA;
     372           0 :         size = avio_rl32(pb);
     373           0 :         if (size < 24)
     374           0 :             return AVERROR_INVALIDDATA;
     375           0 :         avio_rl64(pb); /* RIFF size */
     376             : 
     377           0 :         data_size    = avio_rl64(pb);
     378           0 :         sample_count = avio_rl64(pb);
     379             : 
     380           0 :         if (data_size < 0 || sample_count < 0) {
     381           0 :             av_log(s, AV_LOG_ERROR, "negative data_size and/or sample_count in "
     382             :                    "ds64: data_size = %"PRId64", sample_count = %"PRId64"\n",
     383             :                    data_size, sample_count);
     384           0 :             return AVERROR_INVALIDDATA;
     385             :         }
     386           0 :         avio_skip(pb, size - 24); /* skip rest of ds64 chunk */
     387             : 
     388             :     }
     389             : 
     390         555 :     for (;;) {
     391             :         AVStream *vst;
     392        1061 :         size         = next_tag(pb, &tag, wav->rifx);
     393        1061 :         next_tag_ofs = avio_tell(pb) + size;
     394             : 
     395        1061 :         if (avio_feof(pb))
     396           1 :             break;
     397             : 
     398        1060 :         switch (tag) {
     399         506 :         case MKTAG('f', 'm', 't', ' '):
     400             :             /* only parse the first 'fmt ' tag found */
     401         506 :             if (!got_xma2 && !got_fmt && (ret = wav_parse_fmt_tag(s, size, &st)) < 0) {
     402           0 :                 return ret;
     403         506 :             } else if (got_fmt)
     404           0 :                 av_log(s, AV_LOG_WARNING, "found more than one 'fmt ' tag\n");
     405             : 
     406         506 :             got_fmt = 1;
     407         506 :             break;
     408           0 :         case MKTAG('X', 'M', 'A', '2'):
     409             :             /* only parse the first 'XMA2' tag found */
     410           0 :             if (!got_fmt && !got_xma2 && (ret = wav_parse_xma2_tag(s, size, &st)) < 0) {
     411           0 :                 return ret;
     412           0 :             } else if (got_xma2)
     413           0 :                 av_log(s, AV_LOG_WARNING, "found more than one 'XMA2' tag\n");
     414             : 
     415           0 :             got_xma2 = 1;
     416           0 :             break;
     417         506 :         case MKTAG('d', 'a', 't', 'a'):
     418         506 :             if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) && !got_fmt && !got_xma2) {
     419           0 :                 av_log(s, AV_LOG_ERROR,
     420             :                        "found no 'fmt ' tag before the 'data' tag\n");
     421           0 :                 return AVERROR_INVALIDDATA;
     422             :             }
     423             : 
     424         506 :             if (rf64) {
     425           0 :                 next_tag_ofs = wav->data_end = avio_tell(pb) + data_size;
     426         506 :             } else if (size != 0xFFFFFFFF) {
     427         506 :                 data_size    = size;
     428         506 :                 next_tag_ofs = wav->data_end = size ? next_tag_ofs : INT64_MAX;
     429             :             } else {
     430           0 :                 av_log(s, AV_LOG_WARNING, "Ignoring maximum wav data size, "
     431             :                        "file may be invalid\n");
     432           0 :                 data_size    = 0;
     433           0 :                 next_tag_ofs = wav->data_end = INT64_MAX;
     434             :             }
     435             : 
     436         506 :             data_ofs = avio_tell(pb);
     437             : 
     438             :             /* don't look for footer metadata if we can't seek or if we don't
     439             :              * know where the data tag ends
     440             :              */
     441         506 :             if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || (!rf64 && !size))
     442             :                 goto break_loop;
     443         506 :             break;
     444          35 :         case MKTAG('f', 'a', 'c', 't'):
     445          35 :             if (!sample_count)
     446          35 :                 sample_count = (!wav->rifx ? avio_rl32(pb) : avio_rb32(pb));
     447          35 :             break;
     448           0 :         case MKTAG('b', 'e', 'x', 't'):
     449           0 :             if ((ret = wav_parse_bext_tag(s, size)) < 0)
     450           0 :                 return ret;
     451           0 :             break;
     452           1 :         case MKTAG('S','M','V','0'):
     453           1 :             if (!got_fmt) {
     454           0 :                 av_log(s, AV_LOG_ERROR, "found no 'fmt ' tag before the 'SMV0' tag\n");
     455           0 :                 return AVERROR_INVALIDDATA;
     456             :             }
     457             :             // SMV file, a wav file with video appended.
     458           1 :             if (size != MKTAG('0','2','0','0')) {
     459           0 :                 av_log(s, AV_LOG_ERROR, "Unknown SMV version found\n");
     460           0 :                 goto break_loop;
     461             :             }
     462           1 :             av_log(s, AV_LOG_DEBUG, "Found SMV data\n");
     463           1 :             wav->smv_given_first = 0;
     464           1 :             vst = avformat_new_stream(s, NULL);
     465           1 :             if (!vst)
     466           0 :                 return AVERROR(ENOMEM);
     467           1 :             avio_r8(pb);
     468           1 :             vst->id = 1;
     469           1 :             vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
     470           1 :             vst->codecpar->codec_id = AV_CODEC_ID_SMVJPEG;
     471           1 :             vst->codecpar->width  = avio_rl24(pb);
     472           1 :             vst->codecpar->height = avio_rl24(pb);
     473           1 :             if (ff_alloc_extradata(vst->codecpar, 4)) {
     474           0 :                 av_log(s, AV_LOG_ERROR, "Could not allocate extradata.\n");
     475           0 :                 return AVERROR(ENOMEM);
     476             :             }
     477           1 :             size = avio_rl24(pb);
     478           1 :             wav->smv_data_ofs = avio_tell(pb) + (size - 5) * 3;
     479           1 :             avio_rl24(pb);
     480           1 :             wav->smv_block_size = avio_rl24(pb);
     481           1 :             avpriv_set_pts_info(vst, 32, 1, avio_rl24(pb));
     482           1 :             vst->duration = avio_rl24(pb);
     483           1 :             avio_rl24(pb);
     484           1 :             avio_rl24(pb);
     485           1 :             wav->smv_frames_per_jpeg = avio_rl24(pb);
     486           1 :             if (wav->smv_frames_per_jpeg > 65536) {
     487           0 :                 av_log(s, AV_LOG_ERROR, "too many frames per jpeg\n");
     488           0 :                 return AVERROR_INVALIDDATA;
     489             :             }
     490           1 :             AV_WL32(vst->codecpar->extradata, wav->smv_frames_per_jpeg);
     491           1 :             wav->smv_cur_pt = 0;
     492           1 :             goto break_loop;
     493          11 :         case MKTAG('L', 'I', 'S', 'T'):
     494          11 :             if (size < 4) {
     495           0 :                 av_log(s, AV_LOG_ERROR, "too short LIST tag\n");
     496           0 :                 return AVERROR_INVALIDDATA;
     497             :             }
     498          11 :             switch (avio_rl32(pb)) {
     499          11 :             case MKTAG('I', 'N', 'F', 'O'):
     500          11 :                 ff_read_riff_info(s, size - 4);
     501             :             }
     502          11 :             break;
     503             :         }
     504             : 
     505             :         /* seek to next tag unless we know that we'll run into EOF */
     506        1614 :         if ((avio_size(pb) > 0 && next_tag_ofs >= avio_size(pb)) ||
     507         555 :             wav_seek_tag(wav, pb, next_tag_ofs, SEEK_SET) < 0) {
     508             :             break;
     509             :         }
     510             :     }
     511             : 
     512         504 : break_loop:
     513         506 :     if (!got_fmt && !got_xma2) {
     514           0 :         av_log(s, AV_LOG_ERROR, "no 'fmt ' or 'XMA2' tag found\n");
     515           0 :         return AVERROR_INVALIDDATA;
     516             :     }
     517             : 
     518         506 :     if (data_ofs < 0) {
     519           0 :         av_log(s, AV_LOG_ERROR, "no 'data' tag found\n");
     520           0 :         return AVERROR_INVALIDDATA;
     521             :     }
     522             : 
     523         506 :     avio_seek(pb, data_ofs, SEEK_SET);
     524             : 
     525         506 :     if (data_size > (INT64_MAX>>3)) {
     526           0 :         av_log(s, AV_LOG_WARNING, "Data size %"PRId64" is too large\n", data_size);
     527           0 :         data_size = 0;
     528             :     }
     529             : 
     530         506 :     if (   st->codecpar->bit_rate > 0 && data_size > 0
     531         506 :         && st->codecpar->sample_rate > 0
     532         506 :         && sample_count > 0 && st->codecpar->channels > 1
     533          26 :         && sample_count % st->codecpar->channels == 0) {
     534          44 :         if (fabs(8.0 * data_size * st->codecpar->channels * st->codecpar->sample_rate /
     535          22 :             sample_count /st->codecpar->bit_rate - 1.0) < 0.3)
     536           0 :             sample_count /= st->codecpar->channels;
     537             :     }
     538             : 
     539         506 :     if (   data_size > 0 && sample_count && st->codecpar->channels
     540          35 :         && (data_size << 3) / sample_count / st->codecpar->channels > st->codecpar->bits_per_coded_sample  + 1) {
     541           0 :         av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
     542           0 :         sample_count = 0;
     543             :     }
     544             : 
     545             :     /* G.729 hack (for Ticket4577)
     546             :      * FIXME: Come up with cleaner, more general solution */
     547         506 :     if (st->codecpar->codec_id == AV_CODEC_ID_G729 && sample_count && (data_size << 3) > sample_count) {
     548           0 :         av_log(s, AV_LOG_WARNING, "ignoring wrong sample_count %"PRId64"\n", sample_count);
     549           0 :         sample_count = 0;
     550             :     }
     551             : 
     552         506 :     if (!sample_count || av_get_exact_bits_per_sample(st->codecpar->codec_id) > 0)
     553         491 :         if (   st->codecpar->channels
     554         491 :             && data_size
     555         491 :             && av_get_bits_per_sample(st->codecpar->codec_id)
     556         487 :             && wav->data_end <= avio_size(pb))
     557         970 :             sample_count = (data_size << 3)
     558         485 :                                   /
     559         485 :                 (st->codecpar->channels * (uint64_t)av_get_bits_per_sample(st->codecpar->codec_id));
     560             : 
     561         506 :     if (sample_count)
     562         500 :         st->duration = sample_count;
     563             : 
     564         508 :     if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S32LE &&
     565           4 :         st->codecpar->block_align == st->codecpar->channels * 4 &&
     566           4 :         st->codecpar->bits_per_coded_sample == 32 &&
     567           2 :         st->codecpar->extradata_size == 2 &&
     568           0 :         AV_RL16(st->codecpar->extradata) == 1) {
     569           0 :         st->codecpar->codec_id = AV_CODEC_ID_PCM_F16LE;
     570           0 :         st->codecpar->bits_per_coded_sample = 16;
     571         514 :     } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE &&
     572           8 :                st->codecpar->block_align == st->codecpar->channels * 4 &&
     573           0 :                st->codecpar->bits_per_coded_sample == 24) {
     574           0 :         st->codecpar->codec_id = AV_CODEC_ID_PCM_F24LE;
     575        1012 :     } else if (st->codecpar->codec_id == AV_CODEC_ID_XMA1 ||
     576         506 :                st->codecpar->codec_id == AV_CODEC_ID_XMA2) {
     577           0 :         st->codecpar->block_align = 2048;
     578             :     }
     579             : 
     580         506 :     ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
     581         506 :     ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv);
     582             : 
     583         506 :     set_spdif(s, wav);
     584             : 
     585         506 :     return 0;
     586             : }
     587             : 
     588             : /**
     589             :  * Find chunk with w64 GUID by skipping over other chunks.
     590             :  * @return the size of the found chunk
     591             :  */
     592           6 : static int64_t find_guid(AVIOContext *pb, const uint8_t guid1[16])
     593             : {
     594             :     uint8_t guid[16];
     595             :     int64_t size;
     596             : 
     597          12 :     while (!avio_feof(pb)) {
     598           2 :         avio_read(pb, guid, 16);
     599           2 :         size = avio_rl64(pb);
     600           2 :         if (size <= 24)
     601           2 :             return AVERROR_INVALIDDATA;
     602           0 :         if (!memcmp(guid, guid1, 16))
     603           0 :             return size;
     604           0 :         avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
     605             :     }
     606           4 :     return AVERROR_EOF;
     607             : }
     608             : 
     609             : #define MAX_SIZE 4096
     610             : 
     611       65679 : static int wav_read_packet(AVFormatContext *s, AVPacket *pkt)
     612             : {
     613             :     int ret, size;
     614             :     int64_t left;
     615             :     AVStream *st;
     616       65679 :     WAVDemuxContext *wav = s->priv_data;
     617             : 
     618       65679 :     if (CONFIG_SPDIF_DEMUXER && wav->spdif == 1)
     619          44 :         return ff_spdif_read_packet(s, pkt);
     620             : 
     621       65635 :     if (wav->smv_data_ofs > 0) {
     622             :         int64_t audio_dts, video_dts;
     623          30 : smv_retry:
     624          31 :         audio_dts = (int32_t)s->streams[0]->cur_dts;
     625          31 :         video_dts = (int32_t)s->streams[1]->cur_dts;
     626             : 
     627          31 :         if (audio_dts != AV_NOPTS_VALUE && video_dts != AV_NOPTS_VALUE) {
     628             :             /*We always return a video frame first to get the pixel format first*/
     629          62 :             wav->smv_last_stream = wav->smv_given_first ?
     630          30 :                 av_compare_ts(video_dts, s->streams[1]->time_base,
     631          61 :                               audio_dts, s->streams[0]->time_base) > 0 : 0;
     632          31 :             wav->smv_given_first = 1;
     633             :         }
     634          31 :         wav->smv_last_stream = !wav->smv_last_stream;
     635          31 :         wav->smv_last_stream |= wav->audio_eof;
     636          31 :         wav->smv_last_stream &= !wav->smv_eof;
     637          31 :         if (wav->smv_last_stream) {
     638          13 :             uint64_t old_pos = avio_tell(s->pb);
     639          26 :             uint64_t new_pos = wav->smv_data_ofs +
     640          13 :                 wav->smv_block * wav->smv_block_size;
     641          13 :             if (avio_seek(s->pb, new_pos, SEEK_SET) < 0) {
     642           0 :                 ret = AVERROR_EOF;
     643           0 :                 goto smv_out;
     644             :             }
     645          13 :             size = avio_rl24(s->pb);
     646          13 :             ret  = av_get_packet(s->pb, pkt, size);
     647          13 :             if (ret < 0)
     648           1 :                 goto smv_out;
     649          12 :             pkt->pos -= 3;
     650          12 :             pkt->pts = wav->smv_block * wav->smv_frames_per_jpeg + wav->smv_cur_pt;
     651          12 :             wav->smv_cur_pt++;
     652          12 :             if (wav->smv_frames_per_jpeg > 0)
     653          12 :                 wav->smv_cur_pt %= wav->smv_frames_per_jpeg;
     654          12 :             if (!wav->smv_cur_pt)
     655           2 :                 wav->smv_block++;
     656             : 
     657          12 :             pkt->stream_index = 1;
     658          13 : smv_out:
     659          13 :             avio_seek(s->pb, old_pos, SEEK_SET);
     660          13 :             if (ret == AVERROR_EOF) {
     661           1 :                 wav->smv_eof = 1;
     662           1 :                 goto smv_retry;
     663             :             }
     664          12 :             return ret;
     665             :         }
     666             :     }
     667             : 
     668       65623 :     st = s->streams[0];
     669             : 
     670       65623 :     left = wav->data_end - avio_tell(s->pb);
     671       65623 :     if (wav->ignore_length)
     672           0 :         left = INT_MAX;
     673       65623 :     if (left <= 0) {
     674         364 :         if (CONFIG_W64_DEMUXER && wav->w64)
     675           6 :             left = find_guid(s->pb, ff_w64_guid_data) - 24;
     676             :         else
     677         358 :             left = find_tag(wav, s->pb, MKTAG('d', 'a', 't', 'a'));
     678         364 :         if (left < 0) {
     679         364 :             wav->audio_eof = 1;
     680         364 :             if (wav->smv_data_ofs > 0 && !wav->smv_eof)
     681           0 :                 goto smv_retry;
     682         364 :             return AVERROR_EOF;
     683             :         }
     684           0 :         wav->data_end = avio_tell(s->pb) + left;
     685             :     }
     686             : 
     687       65259 :     size = MAX_SIZE;
     688       65259 :     if (st->codecpar->block_align > 1) {
     689       65161 :         if (size < st->codecpar->block_align)
     690           0 :             size = st->codecpar->block_align;
     691       65161 :         size = (size / st->codecpar->block_align) * st->codecpar->block_align;
     692             :     }
     693       65259 :     size = FFMIN(size, left);
     694       65259 :     ret  = av_get_packet(s->pb, pkt, size);
     695       65259 :     if (ret < 0)
     696           8 :         return ret;
     697       65251 :     pkt->stream_index = 0;
     698             : 
     699       65251 :     return ret;
     700             : }
     701             : 
     702         394 : static int wav_read_seek(AVFormatContext *s,
     703             :                          int stream_index, int64_t timestamp, int flags)
     704             : {
     705         394 :     WAVDemuxContext *wav = s->priv_data;
     706             :     AVStream *st;
     707         394 :     wav->smv_eof = 0;
     708         394 :     wav->audio_eof = 0;
     709         394 :     if (wav->smv_data_ofs > 0) {
     710           0 :         int64_t smv_timestamp = timestamp;
     711           0 :         if (stream_index == 0)
     712           0 :             smv_timestamp = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[1]->time_base);
     713             :         else
     714           0 :             timestamp = av_rescale_q(smv_timestamp, s->streams[1]->time_base, s->streams[0]->time_base);
     715           0 :         if (wav->smv_frames_per_jpeg > 0) {
     716           0 :             wav->smv_block = smv_timestamp / wav->smv_frames_per_jpeg;
     717           0 :             wav->smv_cur_pt = smv_timestamp % wav->smv_frames_per_jpeg;
     718             :         }
     719             :     }
     720             : 
     721         394 :     st = s->streams[0];
     722         394 :     switch (st->codecpar->codec_id) {
     723           0 :     case AV_CODEC_ID_MP2:
     724             :     case AV_CODEC_ID_MP3:
     725             :     case AV_CODEC_ID_AC3:
     726             :     case AV_CODEC_ID_DTS:
     727             :     case AV_CODEC_ID_XMA2:
     728             :         /* use generic seeking with dynamically generated indexes */
     729           0 :         return -1;
     730         394 :     default:
     731         394 :         break;
     732             :     }
     733         394 :     return ff_pcm_read_seek(s, stream_index, timestamp, flags);
     734             : }
     735             : 
     736             : #define OFFSET(x) offsetof(WAVDemuxContext, x)
     737             : #define DEC AV_OPT_FLAG_DECODING_PARAM
     738             : static const AVOption demux_options[] = {
     739             :     { "ignore_length", "Ignore length", OFFSET(ignore_length), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, DEC },
     740             :     { NULL },
     741             : };
     742             : 
     743             : static const AVClass wav_demuxer_class = {
     744             :     .class_name = "WAV demuxer",
     745             :     .item_name  = av_default_item_name,
     746             :     .option     = demux_options,
     747             :     .version    = LIBAVUTIL_VERSION_INT,
     748             : };
     749             : AVInputFormat ff_wav_demuxer = {
     750             :     .name           = "wav",
     751             :     .long_name      = NULL_IF_CONFIG_SMALL("WAV / WAVE (Waveform Audio)"),
     752             :     .priv_data_size = sizeof(WAVDemuxContext),
     753             :     .read_probe     = wav_probe,
     754             :     .read_header    = wav_read_header,
     755             :     .read_packet    = wav_read_packet,
     756             :     .read_seek      = wav_read_seek,
     757             :     .flags          = AVFMT_GENERIC_INDEX,
     758             :     .codec_tag      = (const AVCodecTag * const []) { ff_codec_wav_tags,  0 },
     759             :     .priv_class     = &wav_demuxer_class,
     760             : };
     761             : #endif /* CONFIG_WAV_DEMUXER */
     762             : 
     763             : #if CONFIG_W64_DEMUXER
     764        6130 : static int w64_probe(AVProbeData *p)
     765             : {
     766        6130 :     if (p->buf_size <= 40)
     767           1 :         return 0;
     768        6131 :     if (!memcmp(p->buf,      ff_w64_guid_riff, 16) &&
     769           2 :         !memcmp(p->buf + 24, ff_w64_guid_wave, 16))
     770           2 :         return AVPROBE_SCORE_MAX;
     771             :     else
     772        6127 :         return 0;
     773             : }
     774             : 
     775           2 : static int w64_read_header(AVFormatContext *s)
     776             : {
     777           2 :     int64_t size, data_ofs = 0;
     778           2 :     AVIOContext *pb      = s->pb;
     779           2 :     WAVDemuxContext *wav = s->priv_data;
     780             :     AVStream *st;
     781             :     uint8_t guid[16];
     782             :     int ret;
     783             : 
     784           2 :     avio_read(pb, guid, 16);
     785           2 :     if (memcmp(guid, ff_w64_guid_riff, 16))
     786           0 :         return AVERROR_INVALIDDATA;
     787             : 
     788             :     /* riff + wave + fmt + sizes */
     789           2 :     if (avio_rl64(pb) < 16 + 8 + 16 + 8 + 16 + 8)
     790           0 :         return AVERROR_INVALIDDATA;
     791             : 
     792           2 :     avio_read(pb, guid, 16);
     793           2 :     if (memcmp(guid, ff_w64_guid_wave, 16)) {
     794           0 :         av_log(s, AV_LOG_ERROR, "could not find wave guid\n");
     795           0 :         return AVERROR_INVALIDDATA;
     796             :     }
     797             : 
     798           2 :     wav->w64 = 1;
     799             : 
     800           2 :     st = avformat_new_stream(s, NULL);
     801           2 :     if (!st)
     802           0 :         return AVERROR(ENOMEM);
     803             : 
     804           8 :     while (!avio_feof(pb)) {
     805           6 :         if (avio_read(pb, guid, 16) != 16)
     806           2 :             break;
     807           4 :         size = avio_rl64(pb);
     808           4 :         if (size <= 24 || INT64_MAX - size < avio_tell(pb))
     809           0 :             return AVERROR_INVALIDDATA;
     810             : 
     811           4 :         if (!memcmp(guid, ff_w64_guid_fmt, 16)) {
     812             :             /* subtract chunk header size - normal wav file doesn't count it */
     813           2 :             ret = ff_get_wav_header(s, pb, st->codecpar, size - 24, 0);
     814           2 :             if (ret < 0)
     815           0 :                 return ret;
     816           2 :             avio_skip(pb, FFALIGN(size, INT64_C(8)) - size);
     817             : 
     818           2 :             avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
     819           2 :         } else if (!memcmp(guid, ff_w64_guid_fact, 16)) {
     820             :             int64_t samples;
     821             : 
     822           0 :             samples = avio_rl64(pb);
     823           0 :             if (samples > 0)
     824           0 :                 st->duration = samples;
     825           2 :         } else if (!memcmp(guid, ff_w64_guid_data, 16)) {
     826           2 :             wav->data_end = avio_tell(pb) + size - 24;
     827             : 
     828           2 :             data_ofs = avio_tell(pb);
     829           2 :             if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
     830           0 :                 break;
     831             : 
     832           2 :             avio_skip(pb, size - 24);
     833           0 :         } else if (!memcmp(guid, ff_w64_guid_summarylist, 16)) {
     834             :             int64_t start, end, cur;
     835             :             uint32_t count, chunk_size, i;
     836             : 
     837           0 :             start = avio_tell(pb);
     838           0 :             end = start + FFALIGN(size, INT64_C(8)) - 24;
     839           0 :             count = avio_rl32(pb);
     840             : 
     841           0 :             for (i = 0; i < count; i++) {
     842             :                 char chunk_key[5], *value;
     843             : 
     844           0 :                 if (avio_feof(pb) || (cur = avio_tell(pb)) < 0 || cur > end - 8 /* = tag + size */)
     845             :                     break;
     846             : 
     847           0 :                 chunk_key[4] = 0;
     848           0 :                 avio_read(pb, chunk_key, 4);
     849           0 :                 chunk_size = avio_rl32(pb);
     850           0 :                 if (chunk_size == UINT32_MAX)
     851           0 :                     return AVERROR_INVALIDDATA;
     852             : 
     853           0 :                 value = av_mallocz(chunk_size + 1);
     854           0 :                 if (!value)
     855           0 :                     return AVERROR(ENOMEM);
     856             : 
     857           0 :                 ret = avio_get_str16le(pb, chunk_size, value, chunk_size);
     858           0 :                 avio_skip(pb, chunk_size - ret);
     859             : 
     860           0 :                 av_dict_set(&s->metadata, chunk_key, value, AV_DICT_DONT_STRDUP_VAL);
     861             :             }
     862             : 
     863           0 :             avio_skip(pb, end - avio_tell(pb));
     864             :         } else {
     865           0 :             av_log(s, AV_LOG_DEBUG, "unknown guid: "FF_PRI_GUID"\n", FF_ARG_GUID(guid));
     866           0 :             avio_skip(pb, FFALIGN(size, INT64_C(8)) - 24);
     867             :         }
     868             :     }
     869             : 
     870           2 :     if (!data_ofs)
     871           0 :         return AVERROR_EOF;
     872             : 
     873           2 :     ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
     874           2 :     ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv);
     875             : 
     876           2 :     handle_stream_probing(st);
     877           2 :     st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
     878             : 
     879           2 :     avio_seek(pb, data_ofs, SEEK_SET);
     880             : 
     881           2 :     set_spdif(s, wav);
     882             : 
     883           2 :     return 0;
     884             : }
     885             : 
     886             : AVInputFormat ff_w64_demuxer = {
     887             :     .name           = "w64",
     888             :     .long_name      = NULL_IF_CONFIG_SMALL("Sony Wave64"),
     889             :     .priv_data_size = sizeof(WAVDemuxContext),
     890             :     .read_probe     = w64_probe,
     891             :     .read_header    = w64_read_header,
     892             :     .read_packet    = wav_read_packet,
     893             :     .read_seek      = wav_read_seek,
     894             :     .flags          = AVFMT_GENERIC_INDEX,
     895             :     .codec_tag      = (const AVCodecTag * const []) { ff_codec_wav_tags, 0 },
     896             : };
     897             : #endif /* CONFIG_W64_DEMUXER */

Generated by: LCOV version 1.13