git.sesse.net Git - ffmpeg/blob - libavformat/takdec.c

   1 /*
   2  * Raw TAK demuxer
   3  * Copyright (c) 2012 Paul B Mahol
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #define BITSTREAM_READER_LE
  23 #include "libavcodec/bitstream.h"
  24 #include "libavcodec/tak.h"
  25
  26 #include "apetag.h"
  27 #include "avformat.h"
  28 #include "internal.h"
  29 #include "rawdec.h"
  30
  31 typedef struct TAKDemuxContext {
  32     int     mlast_frame;
  33     int64_t data_end;
  34 } TAKDemuxContext;
  35
  36 static int tak_probe(AVProbeData *p)
  37 {
  38     if (!memcmp(p->buf, "tBaK", 4))
  39         return AVPROBE_SCORE_EXTENSION;
  40     return 0;
  41 }
  42
  43 static int tak_read_header(AVFormatContext *s)
  44 {
  45     TAKDemuxContext *tc = s->priv_data;
  46     AVIOContext *pb     = s->pb;
  47     BitstreamContext bc;
  48     AVStream *st;
  49     uint8_t *buffer = NULL;
  50     int ret;
  51
  52     st = avformat_new_stream(s, 0);
  53     if (!st)
  54         return AVERROR(ENOMEM);
  55
  56     st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
  57     st->codecpar->codec_id   = AV_CODEC_ID_TAK;
  58     st->need_parsing      = AVSTREAM_PARSE_FULL;
  59
  60     tc->mlast_frame = 0;
  61     if (avio_rl32(pb) != MKTAG('t', 'B', 'a', 'K')) {
  62         avio_seek(pb, -4, SEEK_CUR);
  63         return 0;
  64     }
  65
  66     while (!pb->eof_reached) {
  67         enum TAKMetaDataType type;
  68         int size;
  69
  70         type = avio_r8(pb) & 0x7f;
  71         size = avio_rl24(pb);
  72
  73         switch (type) {
  74         case TAK_METADATA_STREAMINFO:
  75         case TAK_METADATA_LAST_FRAME:
  76         case TAK_METADATA_ENCODER:
  77             buffer = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
  78             if (!buffer)
  79                 return AVERROR(ENOMEM);
  80
  81             if (avio_read(pb, buffer, size) != size) {
  82                 av_freep(&buffer);
  83                 return AVERROR(EIO);
  84             }
  85
  86             bitstream_init8(&bc, buffer, size);
  87             break;
  88         case TAK_METADATA_MD5: {
  89             uint8_t md5[16];
  90             int i;
  91
  92             if (size != 19)
  93                 return AVERROR_INVALIDDATA;
  94             avio_read(pb, md5, 16);
  95             avio_skip(pb, 3);
  96             av_log(s, AV_LOG_VERBOSE, "MD5=");
  97             for (i = 0; i < 16; i++)
  98                 av_log(s, AV_LOG_VERBOSE, "%02x", md5[i]);
  99             av_log(s, AV_LOG_VERBOSE, "\n");
 100             break;
 101         }
 102         case TAK_METADATA_END: {
 103             int64_t curpos = avio_tell(pb);
 104
 105             if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
 106                 ff_ape_parse_tag(s);
 107                 avio_seek(pb, curpos, SEEK_SET);
 108             }
 109
 110             tc->data_end += curpos;
 111             return 0;
 112         }
 113         default:
 114             ret = avio_skip(pb, size);
 115             if (ret < 0)
 116                 return ret;
 117         }
 118
 119         if (type == TAK_METADATA_STREAMINFO) {
 120             TAKStreamInfo ti;
 121
 122             avpriv_tak_parse_streaminfo(&bc, &ti);
 123             if (ti.samples > 0)
 124                 st->duration = ti.samples;
 125             st->codecpar->bits_per_coded_sample = ti.bps;
 126             if (ti.ch_layout)
 127                 st->codecpar->channel_layout = ti.ch_layout;
 128             st->codecpar->sample_rate           = ti.sample_rate;
 129             st->codecpar->channels              = ti.channels;
 130             st->start_time                   = 0;
 131             avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
 132             st->codecpar->extradata             = buffer;
 133             st->codecpar->extradata_size        = size;
 134             buffer                           = NULL;
 135         } else if (type == TAK_METADATA_LAST_FRAME) {
 136             if (size != 11)
 137                 return AVERROR_INVALIDDATA;
 138             tc->mlast_frame = 1;
 139             tc->data_end    = bitstream_read_63(&bc, TAK_LAST_FRAME_POS_BITS) +
 140                               bitstream_read(&bc, TAK_LAST_FRAME_SIZE_BITS);
 141             av_freep(&buffer);
 142         } else if (type == TAK_METADATA_ENCODER) {
 143             av_log(s, AV_LOG_VERBOSE, "encoder version: %0X\n",
 144                    bitstream_read(&bc, TAK_ENCODER_VERSION_BITS));
 145             av_freep(&buffer);
 146         }
 147     }
 148
 149     return AVERROR_EOF;
 150 }
 151
 152 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
 153 {
 154     TAKDemuxContext *tc = s->priv_data;
 155     int ret;
 156
 157     if (tc->mlast_frame) {
 158         AVIOContext *pb = s->pb;
 159         int64_t size, left;
 160
 161         left = tc->data_end - avio_tell(s->pb);
 162         size = FFMIN(left, 1024);
 163         if (size <= 0)
 164             return AVERROR_EOF;
 165
 166         ret = av_get_packet(pb, pkt, size);
 167         if (ret < 0)
 168             return ret;
 169
 170         pkt->stream_index = 0;
 171     } else {
 172         ret = ff_raw_read_partial_packet(s, pkt);
 173     }
 174
 175     return ret;
 176 }
 177
 178 AVInputFormat ff_tak_demuxer = {
 179     .name           = "tak",
 180     .long_name      = NULL_IF_CONFIG_SMALL("raw TAK"),
 181     .priv_data_size = sizeof(TAKDemuxContext),
 182     .read_probe     = tak_probe,
 183     .read_header    = tak_read_header,
 184     .read_packet    = raw_read_packet,
 185     .flags          = AVFMT_GENERIC_INDEX,
 186     .extensions     = "tak",
 187     .raw_codec_id   = AV_CODEC_ID_TAK,
 188 };