LCOV - code coverage report
Current view: top level - libavformat - jvdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 100 135 74.1 %
Date: 2017-12-18 06:23:41 Functions: 4 5 80.0 %

          Line data    Source code
       1             : /*
       2             :  * Bitmap Brothers JV demuxer
       3             :  * Copyright (c) 2005, 2011 Peter Ross <pross@xvid.org>
       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             : 
      22             : /**
      23             :  * @file
      24             :  * Bitmap Brothers JV demuxer
      25             :  * @author Peter Ross <pross@xvid.org>
      26             :  */
      27             : 
      28             : #include "libavutil/channel_layout.h"
      29             : #include "libavutil/intreadwrite.h"
      30             : 
      31             : #include "avformat.h"
      32             : #include "internal.h"
      33             : 
      34             : #define JV_PREAMBLE_SIZE 5
      35             : 
      36             : typedef struct JVFrame {
      37             :     int audio_size;    /**< audio packet size (bytes) */
      38             :     int video_size;    /**< video packet size (bytes) */
      39             :     int palette_size;  /**< palette size (bytes) */
      40             :     int video_type;    /**< per-frame video compression type */
      41             : } JVFrame;
      42             : 
      43             : typedef struct JVDemuxContext {
      44             :     JVFrame *frames;
      45             :     enum {
      46             :         JV_AUDIO = 0,
      47             :         JV_VIDEO,
      48             :         JV_PADDING
      49             :     } state;
      50             :     int64_t pts;
      51             : } JVDemuxContext;
      52             : 
      53             : #define MAGIC " Compression by John M Phillips Copyright (C) 1995 The Bitmap Brothers Ltd."
      54             : 
      55        6130 : static int read_probe(AVProbeData *pd)
      56             : {
      57        6132 :     if (pd->buf[0] == 'J' && pd->buf[1] == 'V' && strlen(MAGIC) + 4 <= pd->buf_size &&
      58           2 :         !memcmp(pd->buf + 4, MAGIC, strlen(MAGIC)))
      59           2 :         return AVPROBE_SCORE_MAX;
      60        6128 :     return 0;
      61             : }
      62             : 
      63           2 : static int read_close(AVFormatContext *s)
      64             : {
      65           2 :     JVDemuxContext *jv = s->priv_data;
      66             : 
      67           2 :     av_freep(&jv->frames);
      68             : 
      69           2 :     return 0;
      70             : }
      71             : 
      72           2 : static int read_header(AVFormatContext *s)
      73             : {
      74           2 :     JVDemuxContext *jv = s->priv_data;
      75           2 :     AVIOContext *pb = s->pb;
      76             :     AVStream *vst, *ast;
      77           2 :     int64_t audio_pts = 0;
      78             :     int64_t offset;
      79             :     int i;
      80             : 
      81           2 :     avio_skip(pb, 80);
      82             : 
      83           2 :     ast = avformat_new_stream(s, NULL);
      84           2 :     vst = avformat_new_stream(s, NULL);
      85           2 :     if (!ast || !vst)
      86           0 :         return AVERROR(ENOMEM);
      87             : 
      88           2 :     vst->codecpar->codec_type  = AVMEDIA_TYPE_VIDEO;
      89           2 :     vst->codecpar->codec_id    = AV_CODEC_ID_JV;
      90           2 :     vst->codecpar->codec_tag   = 0; /* no fourcc */
      91           2 :     vst->codecpar->width       = avio_rl16(pb);
      92           2 :     vst->codecpar->height      = avio_rl16(pb);
      93           2 :     vst->duration           =
      94           2 :     vst->nb_frames          =
      95           2 :     ast->nb_index_entries   = avio_rl16(pb);
      96           2 :     avpriv_set_pts_info(vst, 64, avio_rl16(pb), 1000);
      97             : 
      98           2 :     avio_skip(pb, 4);
      99             : 
     100           2 :     ast->codecpar->codec_type     = AVMEDIA_TYPE_AUDIO;
     101           2 :     ast->codecpar->codec_id       = AV_CODEC_ID_PCM_U8;
     102           2 :     ast->codecpar->codec_tag      = 0; /* no fourcc */
     103           2 :     ast->codecpar->sample_rate    = avio_rl16(pb);
     104           2 :     ast->codecpar->channels       = 1;
     105           2 :     ast->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
     106           2 :     avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
     107             : 
     108           2 :     avio_skip(pb, 10);
     109             : 
     110           2 :     ast->index_entries = av_malloc(ast->nb_index_entries *
     111             :                                    sizeof(*ast->index_entries));
     112           2 :     if (!ast->index_entries)
     113           0 :         return AVERROR(ENOMEM);
     114             : 
     115           2 :     jv->frames = av_malloc(ast->nb_index_entries * sizeof(JVFrame));
     116           2 :     if (!jv->frames)
     117           0 :         return AVERROR(ENOMEM);
     118             : 
     119           2 :     offset = 0x68 + ast->nb_index_entries * 16;
     120        4022 :     for (i = 0; i < ast->nb_index_entries; i++) {
     121        4020 :         AVIndexEntry *e   = ast->index_entries + i;
     122        4020 :         JVFrame      *jvf = jv->frames + i;
     123             : 
     124             :         /* total frame size including audio, video, palette data and padding */
     125        4020 :         e->size      = avio_rl32(pb);
     126        4020 :         e->timestamp = i;
     127        4020 :         e->pos       = offset;
     128        4020 :         offset      += e->size;
     129             : 
     130        4020 :         jvf->audio_size   = avio_rl32(pb);
     131        4020 :         jvf->video_size   = avio_rl32(pb);
     132        4020 :         jvf->palette_size = avio_r8(pb) ? 768 : 0;
     133             : 
     134        8040 :         if ((jvf->video_size | jvf->audio_size) & ~0xFFFFFF ||
     135        4020 :             e->size - jvf->audio_size
     136        4020 :                     - jvf->video_size
     137        4020 :                     - jvf->palette_size < 0) {
     138           0 :             if (s->error_recognition & AV_EF_EXPLODE) {
     139           0 :                 read_close(s);
     140           0 :                 return AVERROR_INVALIDDATA;
     141             :             }
     142           0 :             jvf->audio_size   =
     143           0 :             jvf->video_size   =
     144           0 :             jvf->palette_size = 0;
     145             :         }
     146             : 
     147        4020 :         if (avio_r8(pb))
     148           0 :             av_log(s, AV_LOG_WARNING, "unsupported audio codec\n");
     149             : 
     150        4020 :         jvf->video_type = avio_r8(pb);
     151        4020 :         avio_skip(pb, 1);
     152             : 
     153        4020 :         e->timestamp = jvf->audio_size ? audio_pts : AV_NOPTS_VALUE;
     154        4020 :         audio_pts   += jvf->audio_size;
     155             : 
     156        4020 :         e->flags = jvf->video_type != 1 ? AVINDEX_KEYFRAME : 0;
     157             :     }
     158             : 
     159           2 :     jv->state = JV_AUDIO;
     160           2 :     return 0;
     161             : }
     162             : 
     163          38 : static int read_packet(AVFormatContext *s, AVPacket *pkt)
     164             : {
     165          38 :     JVDemuxContext *jv = s->priv_data;
     166          38 :     AVIOContext *pb = s->pb;
     167          38 :     AVStream *ast = s->streams[0];
     168             : 
     169          92 :     while (!avio_feof(s->pb) && jv->pts < ast->nb_index_entries) {
     170          52 :         const AVIndexEntry *e   = ast->index_entries + jv->pts;
     171          52 :         const JVFrame      *jvf = jv->frames + jv->pts;
     172             : 
     173          52 :         switch (jv->state) {
     174          18 :         case JV_AUDIO:
     175          18 :             jv->state++;
     176          18 :             if (jvf->audio_size) {
     177          18 :                 if (av_get_packet(s->pb, pkt, jvf->audio_size) < 0)
     178           0 :                     return AVERROR(ENOMEM);
     179          18 :                 pkt->stream_index = 0;
     180          18 :                 pkt->pts          = e->timestamp;
     181          18 :                 pkt->flags       |= AV_PKT_FLAG_KEY;
     182          18 :                 return 0;
     183             :             }
     184             :         case JV_VIDEO:
     185          18 :             jv->state++;
     186          18 :             if (jvf->video_size || jvf->palette_size) {
     187             :                 int ret;
     188          18 :                 int size = jvf->video_size + jvf->palette_size;
     189          18 :                 if (av_new_packet(pkt, size + JV_PREAMBLE_SIZE))
     190           0 :                     return AVERROR(ENOMEM);
     191             : 
     192          18 :                 AV_WL32(pkt->data, jvf->video_size);
     193          18 :                 pkt->data[4] = jvf->video_type;
     194          18 :                 ret = avio_read(pb, pkt->data + JV_PREAMBLE_SIZE, size);
     195          18 :                 if (ret < 0)
     196           0 :                     return ret;
     197          18 :                 if (ret < size) {
     198           2 :                     memset(pkt->data + JV_PREAMBLE_SIZE + ret, 0,
     199             :                            AV_INPUT_BUFFER_PADDING_SIZE);
     200           2 :                     pkt->flags |= AV_PKT_FLAG_CORRUPT;
     201             :                 }
     202          18 :                 pkt->size         = ret + JV_PREAMBLE_SIZE;
     203          18 :                 pkt->stream_index = 1;
     204          18 :                 pkt->pts          = jv->pts;
     205          18 :                 if (jvf->video_type != 1)
     206           4 :                     pkt->flags |= AV_PKT_FLAG_KEY;
     207          18 :                 return 0;
     208             :             }
     209             :         case JV_PADDING:
     210          16 :             avio_skip(pb, FFMAX(e->size - jvf->audio_size - jvf->video_size
     211             :                                         - jvf->palette_size, 0));
     212          16 :             jv->state = JV_AUDIO;
     213          16 :             jv->pts++;
     214             :         }
     215             :     }
     216             : 
     217           2 :     if (s->pb->eof_reached)
     218           2 :         return AVERROR_EOF;
     219             : 
     220           0 :     return AVERROR(EIO);
     221             : }
     222             : 
     223           0 : static int read_seek(AVFormatContext *s, int stream_index,
     224             :                      int64_t ts, int flags)
     225             : {
     226           0 :     JVDemuxContext *jv = s->priv_data;
     227           0 :     AVStream *ast = s->streams[0];
     228             :     int i;
     229             : 
     230           0 :     if (flags & (AVSEEK_FLAG_BYTE | AVSEEK_FLAG_FRAME))
     231           0 :         return AVERROR(ENOSYS);
     232             : 
     233           0 :     switch (stream_index) {
     234           0 :     case 0:
     235           0 :         i = av_index_search_timestamp(ast, ts, flags);
     236           0 :         break;
     237           0 :     case 1:
     238           0 :         i = ts;
     239           0 :         break;
     240           0 :     default:
     241           0 :         return 0;
     242             :     }
     243             : 
     244           0 :     if (i < 0 || i >= ast->nb_index_entries)
     245           0 :         return 0;
     246           0 :     if (avio_seek(s->pb, ast->index_entries[i].pos, SEEK_SET) < 0)
     247           0 :         return -1;
     248             : 
     249           0 :     jv->state = JV_AUDIO;
     250           0 :     jv->pts   = i;
     251           0 :     return 0;
     252             : }
     253             : 
     254             : AVInputFormat ff_jv_demuxer = {
     255             :     .name           = "jv",
     256             :     .long_name      = NULL_IF_CONFIG_SMALL("Bitmap Brothers JV"),
     257             :     .priv_data_size = sizeof(JVDemuxContext),
     258             :     .read_probe     = read_probe,
     259             :     .read_header    = read_header,
     260             :     .read_packet    = read_packet,
     261             :     .read_seek      = read_seek,
     262             :     .read_close     = read_close,
     263             : };

Generated by: LCOV version 1.13