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: 2018-02-20 21:25:12 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/intreadwrite.h"
      28             : 
      29             : #include "libavcodec/bytestream.h"
      30             : 
      31             : #include "avformat.h"
      32             : #include "internal.h"
      33             : #include "oggdec.h"
      34             : #include "riff.h"
      35             : 
      36             : static int
      37           0 : ogm_header(AVFormatContext *s, int idx)
      38             : {
      39           0 :     struct ogg *ogg = s->priv_data;
      40           0 :     struct ogg_stream *os = ogg->streams + idx;
      41           0 :     AVStream *st = s->streams[idx];
      42             :     GetByteContext p;
      43             :     uint64_t time_unit;
      44             :     uint64_t spu;
      45             :     uint32_t size;
      46             : 
      47           0 :     bytestream2_init(&p, os->buf + os->pstart, os->psize);
      48           0 :     if (!(bytestream2_peek_byte(&p) & 1))
      49           0 :         return 0;
      50             : 
      51           0 :     if (bytestream2_peek_byte(&p) == 1) {
      52           0 :         bytestream2_skip(&p, 1);
      53             : 
      54           0 :         if (bytestream2_peek_byte(&p) == 'v'){
      55             :             int tag;
      56           0 :             st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
      57           0 :             bytestream2_skip(&p, 8);
      58           0 :             tag = bytestream2_get_le32(&p);
      59           0 :             st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag);
      60           0 :             st->codecpar->codec_tag = tag;
      61           0 :             if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4)
      62           0 :                 st->need_parsing = AVSTREAM_PARSE_HEADERS;
      63           0 :         } else if (bytestream2_peek_byte(&p) == 't') {
      64           0 :             st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
      65           0 :             st->codecpar->codec_id = AV_CODEC_ID_TEXT;
      66           0 :             bytestream2_skip(&p, 12);
      67             :         } else {
      68           0 :             uint8_t acid[5] = { 0 };
      69             :             int cid;
      70           0 :             st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
      71           0 :             bytestream2_skip(&p, 8);
      72           0 :             bytestream2_get_buffer(&p, acid, 4);
      73           0 :             acid[4] = 0;
      74           0 :             cid = strtol(acid, NULL, 16);
      75           0 :             st->codecpar->codec_id = ff_codec_get_id(ff_codec_wav_tags, cid);
      76             :             // our parser completely breaks AAC in Ogg
      77           0 :             if (st->codecpar->codec_id != AV_CODEC_ID_AAC)
      78           0 :                 st->need_parsing = AVSTREAM_PARSE_FULL;
      79             :         }
      80             : 
      81           0 :         size        = bytestream2_get_le32(&p);
      82           0 :         size        = FFMIN(size, os->psize);
      83           0 :         time_unit   = bytestream2_get_le64(&p);
      84           0 :         spu         = bytestream2_get_le64(&p);
      85           0 :         if (!time_unit || !spu) {
      86           0 :             av_log(s, AV_LOG_ERROR, "Invalid timing values.\n");
      87           0 :             return AVERROR_INVALIDDATA;
      88             :         }
      89             : 
      90           0 :         bytestream2_skip(&p, 4);    /* default_len */
      91           0 :         bytestream2_skip(&p, 8);    /* buffersize + bits_per_sample */
      92             : 
      93           0 :         if(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
      94           0 :             st->codecpar->width = bytestream2_get_le32(&p);
      95           0 :             st->codecpar->height = bytestream2_get_le32(&p);
      96           0 :             avpriv_set_pts_info(st, 64, time_unit, spu * 10000000);
      97             :         } else {
      98           0 :             st->codecpar->channels = bytestream2_get_le16(&p);
      99           0 :             bytestream2_skip(&p, 2); /* block_align */
     100           0 :             st->codecpar->bit_rate = bytestream2_get_le32(&p) * 8;
     101           0 :             st->codecpar->sample_rate = spu * 10000000 / time_unit;
     102           0 :             avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
     103           0 :             if (size >= 56 && st->codecpar->codec_id == AV_CODEC_ID_AAC) {
     104           0 :                 bytestream2_skip(&p, 4);
     105           0 :                 size -= 4;
     106             :             }
     107           0 :             if (size > 52) {
     108           0 :                 size -= 52;
     109           0 :                 if (bytestream2_get_bytes_left(&p) < size)
     110           0 :                     return AVERROR_INVALIDDATA;
     111           0 :                 av_freep(&st->codecpar->extradata);
     112           0 :                 if (ff_alloc_extradata(st->codecpar, size) < 0)
     113           0 :                     return AVERROR(ENOMEM);
     114           0 :                 bytestream2_get_buffer(&p, st->codecpar->extradata, st->codecpar->extradata_size);
     115             :             }
     116             :         }
     117           0 :     } else if (bytestream2_peek_byte(&p) == 3) {
     118           0 :         bytestream2_skip(&p, 7);
     119           0 :         if (bytestream2_get_bytes_left(&p) > 1)
     120           0 :             ff_vorbis_stream_comment(s, st, p.buffer, bytestream2_get_bytes_left(&p) - 1);
     121             :     }
     122             : 
     123           0 :     return 1;
     124             : }
     125             : 
     126             : static int
     127           0 : ogm_dshow_header(AVFormatContext *s, int idx)
     128             : {
     129           0 :     struct ogg *ogg = s->priv_data;
     130           0 :     struct ogg_stream *os = ogg->streams + idx;
     131           0 :     AVStream *st = s->streams[idx];
     132           0 :     uint8_t *p = os->buf + os->pstart;
     133             :     uint32_t t;
     134             : 
     135           0 :     if(!(*p & 1))
     136           0 :         return 0;
     137           0 :     if(*p != 1)
     138           0 :         return 1;
     139             : 
     140           0 :     if (os->psize < 100)
     141           0 :         return AVERROR_INVALIDDATA;
     142           0 :     t = AV_RL32(p + 96);
     143             : 
     144           0 :     if(t == 0x05589f80){
     145           0 :         if (os->psize < 184)
     146           0 :             return AVERROR_INVALIDDATA;
     147             : 
     148           0 :         st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
     149           0 :         st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, AV_RL32(p + 68));
     150           0 :         avpriv_set_pts_info(st, 64, AV_RL64(p + 164), 10000000);
     151           0 :         st->codecpar->width = AV_RL32(p + 176);
     152           0 :         st->codecpar->height = AV_RL32(p + 180);
     153           0 :     } else if(t == 0x05589f81){
     154           0 :         if (os->psize < 136)
     155           0 :             return AVERROR_INVALIDDATA;
     156             : 
     157           0 :         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
     158           0 :         st->codecpar->codec_id = ff_codec_get_id(ff_codec_wav_tags, AV_RL16(p + 124));
     159           0 :         st->codecpar->channels = AV_RL16(p + 126);
     160           0 :         st->codecpar->sample_rate = AV_RL32(p + 128);
     161           0 :         st->codecpar->bit_rate = AV_RL32(p + 132) * 8;
     162             :     }
     163             : 
     164           0 :     return 1;
     165             : }
     166             : 
     167             : static int
     168           0 : ogm_packet(AVFormatContext *s, int idx)
     169             : {
     170           0 :     struct ogg *ogg = s->priv_data;
     171           0 :     struct ogg_stream *os = ogg->streams + idx;
     172           0 :     uint8_t *p = os->buf + os->pstart;
     173             :     int lb;
     174             : 
     175           0 :     if(*p & 8)
     176           0 :         os->pflags |= AV_PKT_FLAG_KEY;
     177             : 
     178           0 :     lb = ((*p & 2) << 1) | ((*p >> 6) & 3);
     179           0 :     os->pstart += lb + 1;
     180           0 :     os->psize -= lb + 1;
     181             : 
     182           0 :     while (lb--)
     183           0 :         os->pduration += p[lb+1] << (lb*8);
     184             : 
     185           0 :     return 0;
     186             : }
     187             : 
     188             : const struct ogg_codec ff_ogm_video_codec = {
     189             :     .magic = "\001video",
     190             :     .magicsize = 6,
     191             :     .header = ogm_header,
     192             :     .packet = ogm_packet,
     193             :     .granule_is_start = 1,
     194             :     .nb_header = 2,
     195             : };
     196             : 
     197             : const struct ogg_codec ff_ogm_audio_codec = {
     198             :     .magic = "\001audio",
     199             :     .magicsize = 6,
     200             :     .header = ogm_header,
     201             :     .packet = ogm_packet,
     202             :     .granule_is_start = 1,
     203             :     .nb_header = 2,
     204             : };
     205             : 
     206             : const struct ogg_codec ff_ogm_text_codec = {
     207             :     .magic = "\001text",
     208             :     .magicsize = 5,
     209             :     .header = ogm_header,
     210             :     .packet = ogm_packet,
     211             :     .granule_is_start = 1,
     212             :     .nb_header = 2,
     213             : };
     214             : 
     215             : const struct ogg_codec ff_ogm_old_codec = {
     216             :     .magic = "\001Direct Show Samples embedded in Ogg",
     217             :     .magicsize = 35,
     218             :     .header = ogm_dshow_header,
     219             :     .packet = ogm_packet,
     220             :     .granule_is_start = 1,
     221             :     .nb_header = 1,
     222             : };

Generated by: LCOV version 1.13