LCOV - code coverage report
Current view: top level - libavformat - oggparseogm.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 105 0.0 %
Date: 2017-12-11 20:48:03 Functions: 0 3 0.0 %

          Line data    Source code
       1             : /**
       2             :     Copyright (C) 2005  Michael Ahlberg, Måns Rullgård
       3             : 
       4             :     Permission is hereby granted, free of charge, to any person
       5             :     obtaining a copy of this software and associated documentation
       6             :     files (the "Software"), to deal in the Software without
       7             :     restriction, including without limitation the rights to use, copy,
       8             :     modify, merge, publish, distribute, sublicense, and/or sell copies
       9             :     of the Software, and to permit persons to whom the Software is
      10             :     furnished to do so, subject to the following conditions:
      11             : 
      12             :     The above copyright notice and this permission notice shall be
      13             :     included in all copies or substantial portions of the Software.
      14             : 
      15             :     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      16             :     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      17             :     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      18             :     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      19             :     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      20             :     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      21             :     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
      22             :     DEALINGS IN THE SOFTWARE.
      23             : **/
      24             : 
      25             : #include <stdlib.h>
      26             : 
      27             : #include "libavutil/avassert.h"
      28             : #include "libavutil/intreadwrite.h"
      29             : 
      30             : #include "libavcodec/bytestream.h"
      31             : 
      32             : #include "avformat.h"
      33             : #include "internal.h"
      34             : #include "oggdec.h"
      35             : #include "riff.h"
      36             : 
      37             : static int
      38           0 : ogm_header(AVFormatContext *s, int idx)
      39             : {
      40           0 :     struct ogg *ogg = s->priv_data;
      41           0 :     struct ogg_stream *os = ogg->streams + idx;
      42           0 :     AVStream *st = s->streams[idx];
      43             :     GetByteContext p;
      44             :     uint64_t time_unit;
      45             :     uint64_t spu;
      46             :     uint32_t size;
      47             : 
      48           0 :     bytestream2_init(&p, os->buf + os->pstart, os->psize);
      49           0 :     if (!(bytestream2_peek_byte(&p) & 1))
      50           0 :         return 0;
      51             : 
      52           0 :     if (bytestream2_peek_byte(&p) == 1) {
      53           0 :         bytestream2_skip(&p, 1);
      54             : 
      55           0 :         if (bytestream2_peek_byte(&p) == 'v'){
      56             :             int tag;
      57           0 :             st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
      58           0 :             bytestream2_skip(&p, 8);
      59           0 :             tag = bytestream2_get_le32(&p);
      60           0 :             st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag);
      61           0 :             st->codecpar->codec_tag = tag;
      62           0 :             if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4)
      63           0 :                 st->need_parsing = AVSTREAM_PARSE_HEADERS;
      64           0 :         } else if (bytestream2_peek_byte(&p) == 't') {
      65           0 :             st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
      66           0 :             st->codecpar->codec_id = AV_CODEC_ID_TEXT;
      67           0 :             bytestream2_skip(&p, 12);
      68             :         } else {
      69           0 :             uint8_t acid[5] = { 0 };
      70             :             int cid;
      71           0 :             st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
      72           0 :             bytestream2_skip(&p, 8);
      73           0 :             bytestream2_get_buffer(&p, acid, 4);
      74           0 :             acid[4] = 0;
      75           0 :             cid = strtol(acid, NULL, 16);
      76           0 :             st->codecpar->codec_id = ff_codec_get_id(ff_codec_wav_tags, cid);
      77             :             // our parser completely breaks AAC in Ogg
      78           0 :             if (st->codecpar->codec_id != AV_CODEC_ID_AAC)
      79           0 :                 st->need_parsing = AVSTREAM_PARSE_FULL;
      80             :         }
      81             : 
      82           0 :         size        = bytestream2_get_le32(&p);
      83           0 :         size        = FFMIN(size, os->psize);
      84           0 :         time_unit   = bytestream2_get_le64(&p);
      85           0 :         spu         = bytestream2_get_le64(&p);
      86           0 :         if (!time_unit || !spu) {
      87           0 :             av_log(s, AV_LOG_ERROR, "Invalid timing values.\n");
      88           0 :             return AVERROR_INVALIDDATA;
      89             :         }
      90             : 
      91           0 :         bytestream2_skip(&p, 4);    /* default_len */
      92           0 :         bytestream2_skip(&p, 8);    /* buffersize + bits_per_sample */
      93             : 
      94           0 :         if(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
      95           0 :             st->codecpar->width = bytestream2_get_le32(&p);
      96           0 :             st->codecpar->height = bytestream2_get_le32(&p);
      97           0 :             avpriv_set_pts_info(st, 64, time_unit, spu * 10000000);
      98             :         } else {
      99           0 :             st->codecpar->channels = bytestream2_get_le16(&p);
     100           0 :             bytestream2_skip(&p, 2); /* block_align */
     101           0 :             st->codecpar->bit_rate = bytestream2_get_le32(&p) * 8;
     102           0 :             st->codecpar->sample_rate = spu * 10000000 / time_unit;
     103           0 :             avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
     104           0 :             if (size >= 56 && st->codecpar->codec_id == AV_CODEC_ID_AAC) {
     105           0 :                 bytestream2_skip(&p, 4);
     106           0 :                 size -= 4;
     107             :             }
     108           0 :             if (size > 52) {
     109             :                 av_assert0(AV_INPUT_BUFFER_PADDING_SIZE <= 52);
     110           0 :                 size -= 52;
     111           0 :                 if (bytestream2_get_bytes_left(&p) < size)
     112           0 :                     return AVERROR_INVALIDDATA;
     113           0 :                 av_freep(&st->codecpar->extradata);
     114           0 :                 if (ff_alloc_extradata(st->codecpar, size) < 0)
     115           0 :                     return AVERROR(ENOMEM);
     116           0 :                 bytestream2_get_buffer(&p, st->codecpar->extradata, st->codecpar->extradata_size);
     117             :             }
     118             :         }
     119           0 :     } else if (bytestream2_peek_byte(&p) == 3) {
     120           0 :         bytestream2_skip(&p, 7);
     121           0 :         if (bytestream2_get_bytes_left(&p) > 1)
     122           0 :             ff_vorbis_stream_comment(s, st, p.buffer, bytestream2_get_bytes_left(&p) - 1);
     123             :     }
     124             : 
     125           0 :     return 1;
     126             : }
     127             : 
     128             : static int
     129           0 : ogm_dshow_header(AVFormatContext *s, int idx)
     130             : {
     131           0 :     struct ogg *ogg = s->priv_data;
     132           0 :     struct ogg_stream *os = ogg->streams + idx;
     133           0 :     AVStream *st = s->streams[idx];
     134           0 :     uint8_t *p = os->buf + os->pstart;
     135             :     uint32_t t;
     136             : 
     137           0 :     if(!(*p & 1))
     138           0 :         return 0;
     139           0 :     if(*p != 1)
     140           0 :         return 1;
     141             : 
     142           0 :     if (os->psize < 100)
     143           0 :         return AVERROR_INVALIDDATA;
     144           0 :     t = AV_RL32(p + 96);
     145             : 
     146           0 :     if(t == 0x05589f80){
     147           0 :         if (os->psize < 184)
     148           0 :             return AVERROR_INVALIDDATA;
     149             : 
     150           0 :         st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
     151           0 :         st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, AV_RL32(p + 68));
     152           0 :         avpriv_set_pts_info(st, 64, AV_RL64(p + 164), 10000000);
     153           0 :         st->codecpar->width = AV_RL32(p + 176);
     154           0 :         st->codecpar->height = AV_RL32(p + 180);
     155           0 :     } else if(t == 0x05589f81){
     156           0 :         if (os->psize < 136)
     157           0 :             return AVERROR_INVALIDDATA;
     158             : 
     159           0 :         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
     160           0 :         st->codecpar->codec_id = ff_codec_get_id(ff_codec_wav_tags, AV_RL16(p + 124));
     161           0 :         st->codecpar->channels = AV_RL16(p + 126);
     162           0 :         st->codecpar->sample_rate = AV_RL32(p + 128);
     163           0 :         st->codecpar->bit_rate = AV_RL32(p + 132) * 8;
     164             :     }
     165             : 
     166           0 :     return 1;
     167             : }
     168             : 
     169             : static int
     170           0 : ogm_packet(AVFormatContext *s, int idx)
     171             : {
     172           0 :     struct ogg *ogg = s->priv_data;
     173           0 :     struct ogg_stream *os = ogg->streams + idx;
     174           0 :     uint8_t *p = os->buf + os->pstart;
     175             :     int lb;
     176             : 
     177           0 :     if(*p & 8)
     178           0 :         os->pflags |= AV_PKT_FLAG_KEY;
     179             : 
     180           0 :     lb = ((*p & 2) << 1) | ((*p >> 6) & 3);
     181           0 :     os->pstart += lb + 1;
     182           0 :     os->psize -= lb + 1;
     183             : 
     184           0 :     while (lb--)
     185           0 :         os->pduration += p[lb+1] << (lb*8);
     186             : 
     187           0 :     return 0;
     188             : }
     189             : 
     190             : const struct ogg_codec ff_ogm_video_codec = {
     191             :     .magic = "\001video",
     192             :     .magicsize = 6,
     193             :     .header = ogm_header,
     194             :     .packet = ogm_packet,
     195             :     .granule_is_start = 1,
     196             :     .nb_header = 2,
     197             : };
     198             : 
     199             : const struct ogg_codec ff_ogm_audio_codec = {
     200             :     .magic = "\001audio",
     201             :     .magicsize = 6,
     202             :     .header = ogm_header,
     203             :     .packet = ogm_packet,
     204             :     .granule_is_start = 1,
     205             :     .nb_header = 2,
     206             : };
     207             : 
     208             : const struct ogg_codec ff_ogm_text_codec = {
     209             :     .magic = "\001text",
     210             :     .magicsize = 5,
     211             :     .header = ogm_header,
     212             :     .packet = ogm_packet,
     213             :     .granule_is_start = 1,
     214             :     .nb_header = 2,
     215             : };
     216             : 
     217             : const struct ogg_codec ff_ogm_old_codec = {
     218             :     .magic = "\001Direct Show Samples embedded in Ogg",
     219             :     .magicsize = 35,
     220             :     .header = ogm_dshow_header,
     221             :     .packet = ogm_packet,
     222             :     .granule_is_start = 1,
     223             :     .nb_header = 1,
     224             : };

Generated by: LCOV version 1.13