RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
ffmpeg/libavformat/ty.c

790 lines
27 KiB
C
Raw Blame History

/*
* TiVo ty stream demuxer
* Copyright (c) 2005 VLC authors and VideoLAN
* Copyright (c) 2005 by Neal Symms (tivo@freakinzoo.com) - February 2005
* based on code by Christopher Wingert for tivo-mplayer
* tivo(at)wingert.org, February 2003
* Copyright (c) 2017 Paul B Mahol
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/intreadwrite.h"
#include "avformat.h"
#include "internal.h"
#include "mpeg.h"
#define SERIES1_PES_LENGTH 11 /* length of audio PES hdr on S1 */
#define SERIES2_PES_LENGTH 16 /* length of audio PES hdr on S2 */
#define AC3_PES_LENGTH 14 /* length of audio PES hdr for AC3 */
#define VIDEO_PES_LENGTH 16 /* length of video PES header */
#define DTIVO_PTS_OFFSET 6 /* offs into PES for MPEG PTS on DTivo */
#define SA_PTS_OFFSET 9 /* offset into PES for MPEG PTS on SA */
#define AC3_PTS_OFFSET 9 /* offset into PES for AC3 PTS on DTivo */
#define VIDEO_PTS_OFFSET 9 /* offset into PES for video PTS on all */
#define AC3_PKT_LENGTH 1536 /* size of TiVo AC3 pkts (w/o PES hdr) */
static const uint8_t ty_VideoPacket[] = { 0x00, 0x00, 0x01, 0xe0 };
static const uint8_t ty_MPEGAudioPacket[] = { 0x00, 0x00, 0x01, 0xc0 };
static const uint8_t ty_AC3AudioPacket[] = { 0x00, 0x00, 0x01, 0xbd };
#define TIVO_PES_FILEID 0xf5467abd
#define CHUNK_SIZE (128 * 1024)
#define CHUNK_PEEK_COUNT 3 /* number of chunks to probe */
typedef struct TyRecHdr {
int32_t rec_size;
uint8_t ex[2];
uint8_t rec_type;
uint8_t subrec_type;
uint64_t ty_pts; /* TY PTS in the record header */
} TyRecHdr;
typedef enum {
TIVO_TYPE_UNKNOWN,
TIVO_TYPE_SA,
TIVO_TYPE_DTIVO
} TiVo_type;
typedef enum {
TIVO_SERIES_UNKNOWN,
TIVO_SERIES1,
TIVO_SERIES2
} TiVo_series;
typedef enum {
TIVO_AUDIO_UNKNOWN,
TIVO_AUDIO_AC3,
TIVO_AUDIO_MPEG
} TiVo_audio;
typedef struct TySeqTable {
uint64_t timestamp;
uint8_t chunk_bitmask[8];
} TySeqTable;
typedef struct TYDemuxContext {
unsigned cur_chunk;
unsigned cur_chunk_pos;
int64_t cur_pos;
TiVo_type tivo_type; /* TiVo type (SA / DTiVo) */
TiVo_series tivo_series; /* Series1 or Series2 */
TiVo_audio audio_type; /* AC3 or MPEG */
int pes_length; /* Length of Audio PES header */
int pts_offset; /* offset into audio PES of PTS */
uint8_t pes_buffer[20]; /* holds incomplete pes headers */
int pes_buf_cnt; /* how many bytes in our buffer */
size_t ac3_pkt_size; /* length of ac3 pkt we've seen so far */
uint64_t last_ty_pts; /* last TY timestamp we've seen */
unsigned seq_table_size; /* number of entries in SEQ table */
int64_t first_audio_pts;
int64_t last_audio_pts;
int64_t last_video_pts;
TyRecHdr *rec_hdrs; /* record headers array */
int cur_rec; /* current record in this chunk */
int num_recs; /* number of recs in this chunk */
int seq_rec; /* record number where seq start is */
TySeqTable *seq_table; /* table of SEQ entries from mstr chk */
int first_chunk;
uint8_t chunk[CHUNK_SIZE];
} TYDemuxContext;
static int ty_probe(const AVProbeData *p)
{
int i;
for (i = 0; i + 12 < p->buf_size; i += CHUNK_SIZE) {
if (AV_RB32(p->buf + i) == TIVO_PES_FILEID &&
AV_RB32(p->buf + i + 4) == 0x02 &&
AV_RB32(p->buf + i + 8) == CHUNK_SIZE) {
return AVPROBE_SCORE_MAX;
}
}
return 0;
}
static TyRecHdr *parse_chunk_headers(const uint8_t *buf,
int num_recs)
{
TyRecHdr *hdrs, *rec_hdr;
int i;
hdrs = av_calloc(num_recs, sizeof(TyRecHdr));
if (!hdrs)
return NULL;
for (i = 0; i < num_recs; i++) {
const uint8_t *record_header = buf + (i * 16);
rec_hdr = &hdrs[i]; /* for brevity */
rec_hdr->rec_type = record_header[3];
rec_hdr->subrec_type = record_header[2] & 0x0f;
if ((record_header[0] & 0x80) == 0x80) {
uint8_t b1, b2;
/* marker bit 2 set, so read extended data */
b1 = (((record_header[0] & 0x0f) << 4) |
((record_header[1] & 0xf0) >> 4));
b2 = (((record_header[1] & 0x0f) << 4) |
((record_header[2] & 0xf0) >> 4));
rec_hdr->ex[0] = b1;
rec_hdr->ex[1] = b2;
rec_hdr->rec_size = 0;
rec_hdr->ty_pts = 0;
} else {
rec_hdr->rec_size = (record_header[0] << 8 |
record_header[1]) << 4 |
(record_header[2] >> 4);
rec_hdr->ty_pts = AV_RB64(&record_header[8]);
}
}
return hdrs;
}
static int find_es_header(const uint8_t *header,
const uint8_t *buffer, int search_len)
{
int count;
for (count = 0; count < search_len; count++) {
if (!memcmp(&buffer[count], header, 4))
return count;
}
return -1;
}
static int analyze_chunk(AVFormatContext *s, const uint8_t *chunk)
{
TYDemuxContext *ty = s->priv_data;
int num_recs, i;
TyRecHdr *hdrs;
int num_6e0, num_be0, num_9c0, num_3c0;
/* skip if it's a Part header */
if (AV_RB32(&chunk[0]) == TIVO_PES_FILEID)
return 0;
/* number of records in chunk (we ignore high order byte;
* rarely are there > 256 chunks & we don't need that many anyway) */
num_recs = chunk[0];
if (num_recs < 5) {
/* try again with the next chunk. Sometimes there are dead ones */
return 0;
}
chunk += 4; /* skip past rec count & SEQ bytes */
ff_dlog(s, "probe: chunk has %d recs\n", num_recs);
hdrs = parse_chunk_headers(chunk, num_recs);
if (!hdrs)
return AVERROR(ENOMEM);
/* scan headers.
* 1. check video packets. Presence of 0x6e0 means S1.
* No 6e0 but have be0 means S2.
* 2. probe for audio 0x9c0 vs 0x3c0 (AC3 vs Mpeg)
* If AC-3, then we have DTivo.
* If MPEG, search for PTS offset. This will determine SA vs. DTivo.
*/
num_6e0 = num_be0 = num_9c0 = num_3c0 = 0;
for (i = 0; i < num_recs; i++) {
switch (hdrs[i].subrec_type << 8 | hdrs[i].rec_type) {
case 0x6e0:
num_6e0++;
break;
case 0xbe0:
num_be0++;
break;
case 0x3c0:
num_3c0++;
break;
case 0x9c0:
num_9c0++;
break;
}
}
ff_dlog(s, "probe: chunk has %d 0x6e0 recs, %d 0xbe0 recs.\n",
num_6e0, num_be0);
/* set up our variables */
if (num_6e0 > 0) {
ff_dlog(s, "detected Series 1 Tivo\n");
ty->tivo_series = TIVO_SERIES1;
ty->pes_length = SERIES1_PES_LENGTH;
} else if (num_be0 > 0) {
ff_dlog(s, "detected Series 2 Tivo\n");
ty->tivo_series = TIVO_SERIES2;
ty->pes_length = SERIES2_PES_LENGTH;
}
if (num_9c0 > 0) {
ff_dlog(s, "detected AC-3 Audio (DTivo)\n");
ty->audio_type = TIVO_AUDIO_AC3;
ty->tivo_type = TIVO_TYPE_DTIVO;
ty->pts_offset = AC3_PTS_OFFSET;
ty->pes_length = AC3_PES_LENGTH;
} else if (num_3c0 > 0) {
ty->audio_type = TIVO_AUDIO_MPEG;
ff_dlog(s, "detected MPEG Audio\n");
}
/* if tivo_type still unknown, we can check PTS location
* in MPEG packets to determine tivo_type */
if (ty->tivo_type == TIVO_TYPE_UNKNOWN) {
uint32_t data_offset = 16 * num_recs;
for (i = 0; i < num_recs; i++) {
if (data_offset + hdrs[i].rec_size > CHUNK_SIZE)
break;
if ((hdrs[i].subrec_type << 8 | hdrs[i].rec_type) == 0x3c0 && hdrs[i].rec_size > 15) {
/* first make sure we're aligned */
int pes_offset = find_es_header(ty_MPEGAudioPacket,
&chunk[data_offset], 5);
if (pes_offset >= 0) {
/* pes found. on SA, PES has hdr data at offset 6, not PTS. */
if ((chunk[data_offset + 6 + pes_offset] & 0x80) == 0x80) {
/* S1SA or S2(any) Mpeg Audio (PES hdr, not a PTS start) */
if (ty->tivo_series == TIVO_SERIES1)
ff_dlog(s, "detected Stand-Alone Tivo\n");
ty->tivo_type = TIVO_TYPE_SA;
ty->pts_offset = SA_PTS_OFFSET;
} else {
if (ty->tivo_series == TIVO_SERIES1)
ff_dlog(s, "detected DirecTV Tivo\n");
ty->tivo_type = TIVO_TYPE_DTIVO;
ty->pts_offset = DTIVO_PTS_OFFSET;
}
break;
}
}
data_offset += hdrs[i].rec_size;
}
}
av_free(hdrs);
return 0;
}
static int ty_read_header(AVFormatContext *s)
{
TYDemuxContext *ty = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st, *ast;
int i, ret = 0;
ty->first_audio_pts = AV_NOPTS_VALUE;
ty->last_audio_pts = AV_NOPTS_VALUE;
ty->last_video_pts = AV_NOPTS_VALUE;
for (i = 0; i < CHUNK_PEEK_COUNT; i++) {
avio_read(pb, ty->chunk, CHUNK_SIZE);
ret = analyze_chunk(s, ty->chunk);
if (ret < 0)
return ret;
if (ty->tivo_series != TIVO_SERIES_UNKNOWN &&
ty->audio_type != TIVO_AUDIO_UNKNOWN &&
ty->tivo_type != TIVO_TYPE_UNKNOWN)
break;
}
if (ty->tivo_series == TIVO_SERIES_UNKNOWN ||
ty->audio_type == TIVO_AUDIO_UNKNOWN ||
ty->tivo_type == TIVO_TYPE_UNKNOWN)
return AVERROR(EIO);
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
st->codecpar->codec_id = AV_CODEC_ID_MPEG2VIDEO;
st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
avpriv_set_pts_info(st, 64, 1, 90000);
ast = avformat_new_stream(s, NULL);
if (!ast)
return AVERROR(ENOMEM);
ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
if (ty->audio_type == TIVO_AUDIO_MPEG) {
ast->codecpar->codec_id = AV_CODEC_ID_MP2;
ast->need_parsing = AVSTREAM_PARSE_FULL_RAW;
} else {
ast->codecpar->codec_id = AV_CODEC_ID_AC3;
}
avpriv_set_pts_info(ast, 64, 1, 90000);
ty->first_chunk = 1;
avio_seek(pb, 0, SEEK_SET);
return 0;
}
/* parse a master chunk, filling the SEQ table and other variables.
* We assume the stream is currently pointing to it.
*/
static void parse_master(AVFormatContext *s)
{
TYDemuxContext *ty = s->priv_data;
unsigned map_size; /* size of bitmask, in bytes */
unsigned i, j;
/* Note that the entries in the SEQ table in the stream may have
different sizes depending on the bits per entry. We store them
all in the same size structure, so we have to parse them out one
by one. If we had a dynamic structure, we could simply read the
entire table directly from the stream into memory in place. */
/* clear the SEQ table */
av_freep(&ty->seq_table);
/* parse header info */
map_size = AV_RB32(ty->chunk + 20); /* size of bitmask, in bytes */
i = AV_RB32(ty->chunk + 28); /* size of SEQ table, in bytes */
ty->seq_table_size = i / (8LL + map_size);
if (ty->seq_table_size == 0) {
ty->seq_table = NULL;
return;
}
/* parse all the entries */
ty->seq_table = av_calloc(ty->seq_table_size, sizeof(TySeqTable));
if (ty->seq_table == NULL) {
ty->seq_table_size = 0;
return;
}
ty->cur_chunk_pos = 32;
for (j = 0; j < ty->seq_table_size; j++) {
if (ty->cur_chunk_pos >= CHUNK_SIZE - 8)
return;
ty->seq_table[j].timestamp = AV_RB64(ty->chunk + ty->cur_chunk_pos);
ty->cur_chunk_pos += 8;
if (map_size > 8) {
av_log(s, AV_LOG_ERROR, "Unsupported SEQ bitmap size in master chunk.\n");
ty->cur_chunk_pos += map_size;
} else {
memcpy(ty->seq_table[j].chunk_bitmask, ty->chunk + ty->cur_chunk_pos, map_size);
}
}
}
static int get_chunk(AVFormatContext *s)
{
TYDemuxContext *ty = s->priv_data;
AVIOContext *pb = s->pb;
int read_size, num_recs;
ff_dlog(s, "parsing ty chunk #%d\n", ty->cur_chunk);
/* if we have left-over filler space from the last chunk, get that */
if (avio_feof(pb))
return AVERROR_EOF;
/* read the TY packet header */
read_size = avio_read(pb, ty->chunk, CHUNK_SIZE);
ty->cur_chunk++;
if ((read_size < 4) || (AV_RB32(ty->chunk) == 0)) {
return AVERROR_EOF;
}
/* check if it's a PART Header */
if (AV_RB32(ty->chunk) == TIVO_PES_FILEID) {
parse_master(s); /* parse master chunk */
return get_chunk(s);
}
/* number of records in chunk (8- or 16-bit number) */
if (ty->chunk[3] & 0x80) {
/* 16 bit rec cnt */
ty->num_recs = num_recs = (ty->chunk[1] << 8) + ty->chunk[0];
ty->seq_rec = (ty->chunk[3] << 8) + ty->chunk[2];
if (ty->seq_rec != 0xffff) {
ty->seq_rec &= ~0x8000;
}
} else {
/* 8 bit reclen - TiVo 1.3 format */
ty->num_recs = num_recs = ty->chunk[0];
ty->seq_rec = ty->chunk[1];
}
ty->cur_rec = 0;
ty->first_chunk = 0;
ff_dlog(s, "chunk has %d records\n", num_recs);
ty->cur_chunk_pos = 4;
av_freep(&ty->rec_hdrs);
if (num_recs * 16 >= CHUNK_SIZE - 4)
return AVERROR_INVALIDDATA;
ty->rec_hdrs = parse_chunk_headers(ty->chunk + 4, num_recs);
if (!ty->rec_hdrs)
return AVERROR(ENOMEM);
ty->cur_chunk_pos += 16 * num_recs;
return 0;
}
static int demux_video(AVFormatContext *s, TyRecHdr *rec_hdr, AVPacket *pkt)
{
TYDemuxContext *ty = s->priv_data;
const int subrec_type = rec_hdr->subrec_type;
const int64_t rec_size = rec_hdr->rec_size;
int es_offset1;
int got_packet = 0;
if (subrec_type != 0x02 && subrec_type != 0x0c &&
subrec_type != 0x08 && rec_size > 4) {
/* get the PTS from this packet if it has one.
* on S1, only 0x06 has PES. On S2, however, most all do.
* Do NOT Pass the PES Header to the MPEG2 codec */
es_offset1 = find_es_header(ty_VideoPacket, ty->chunk + ty->cur_chunk_pos, 5);
if (es_offset1 != -1) {
ty->last_video_pts = ff_parse_pes_pts(
ty->chunk + ty->cur_chunk_pos + es_offset1 + VIDEO_PTS_OFFSET);
if (subrec_type != 0x06) {
/* if we found a PES, and it's not type 6, then we're S2 */
/* The packet will have video data (& other headers) so we
* chop out the PES header and send the rest */
if (rec_size >= VIDEO_PES_LENGTH + es_offset1) {
int size = rec_hdr->rec_size - VIDEO_PES_LENGTH - es_offset1;
ty->cur_chunk_pos += VIDEO_PES_LENGTH + es_offset1;
if (av_new_packet(pkt, size) < 0)
return AVERROR(ENOMEM);
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, size);
ty->cur_chunk_pos += size;
pkt->stream_index = 0;
got_packet = 1;
} else {
ff_dlog(s, "video rec type 0x%02x has short PES"
" (%"PRId64" bytes)\n", subrec_type, rec_size);
/* nuke this block; it's too short, but has PES marker */
ty->cur_chunk_pos += rec_size;
return 0;
}
}
}
}
if (subrec_type == 0x06) {
/* type 6 (S1 DTivo) has no data, so we're done */
ty->cur_chunk_pos += rec_size;
return 0;
}
if (!got_packet) {
if (av_new_packet(pkt, rec_size) < 0)
return AVERROR(ENOMEM);
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size;
pkt->stream_index = 0;
got_packet = 1;
}
/* if it's not a continue blk, then set PTS */
if (subrec_type != 0x02) {
if (subrec_type == 0x0c && pkt->size >= 6)
pkt->data[5] |= 0x08;
if (subrec_type == 0x07) {
ty->last_ty_pts = rec_hdr->ty_pts;
} else {
/* yes I know this is a cheap hack. It's the timestamp
used for display and skipping fwd/back, so it
doesn't have to be accurate to the millisecond.
I adjust it here by roughly one 1/30 sec. Yes it
will be slightly off for UK streams, but it's OK.
*/
ty->last_ty_pts += 35000000;
//ty->last_ty_pts += 33366667;
}
/* set PTS for this block before we send */
if (ty->last_video_pts > AV_NOPTS_VALUE) {
pkt->pts = ty->last_video_pts;
/* PTS gets used ONCE.
* Any subsequent frames we get BEFORE next PES
* header will have their PTS computed in the codec */
ty->last_video_pts = AV_NOPTS_VALUE;
}
}
return got_packet;
}
static int check_sync_pes(AVFormatContext *s, AVPacket *pkt,
int32_t offset, int32_t rec_len)
{
TYDemuxContext *ty = s->priv_data;
if (offset < 0 || offset + ty->pes_length > rec_len) {
/* entire PES header not present */
ff_dlog(s, "PES header at %"PRId32" not complete in record. storing.\n", offset);
/* save the partial pes header */
if (offset < 0) {
/* no header found, fake some 00's (this works, believe me) */
memset(ty->pes_buffer, 0, 4);
ty->pes_buf_cnt = 4;
if (rec_len > 4)
ff_dlog(s, "PES header not found in record of %"PRId32" bytes!\n", rec_len);
return -1;
}
/* copy the partial pes header we found */
memcpy(ty->pes_buffer, pkt->data + offset, rec_len - offset);
ty->pes_buf_cnt = rec_len - offset;
if (offset > 0) {
/* PES Header was found, but not complete, so trim the end of this record */
pkt->size -= rec_len - offset;
return 1;
}
return -1; /* partial PES, no audio data */
}
/* full PES header present, extract PTS */
ty->last_audio_pts = ff_parse_pes_pts(&pkt->data[ offset + ty->pts_offset]);
if (ty->first_audio_pts == AV_NOPTS_VALUE)
ty->first_audio_pts = ty->last_audio_pts;
pkt->pts = ty->last_audio_pts;
memmove(pkt->data + offset, pkt->data + offset + ty->pes_length, rec_len - ty->pes_length);
pkt->size -= ty->pes_length;
return 0;
}
static int demux_audio(AVFormatContext *s, TyRecHdr *rec_hdr, AVPacket *pkt)
{
TYDemuxContext *ty = s->priv_data;
const int subrec_type = rec_hdr->subrec_type;
const int64_t rec_size = rec_hdr->rec_size;
int es_offset1;
if (subrec_type == 2) {
int need = 0;
/* SA or DTiVo Audio Data, no PES (continued block)
* ================================================
*/
/* continue PES if previous was incomplete */
if (ty->pes_buf_cnt > 0) {
need = ty->pes_length - ty->pes_buf_cnt;
ff_dlog(s, "continuing PES header\n");
/* do we have enough data to complete? */
if (need >= rec_size) {
/* don't have complete PES hdr; save what we have and return */
memcpy(ty->pes_buffer + ty->pes_buf_cnt, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size;
ty->pes_buf_cnt += rec_size;
return 0;
}
/* we have enough; reconstruct this frame with the new hdr */
memcpy(ty->pes_buffer + ty->pes_buf_cnt, ty->chunk + ty->cur_chunk_pos, need);
ty->cur_chunk_pos += need;
/* get the PTS out of this PES header (MPEG or AC3) */
if (ty->audio_type == TIVO_AUDIO_MPEG) {
es_offset1 = find_es_header(ty_MPEGAudioPacket,
ty->pes_buffer, 5);
} else {
es_offset1 = find_es_header(ty_AC3AudioPacket,
ty->pes_buffer, 5);
}
if (es_offset1 < 0) {
ff_dlog(s, "Can't find audio PES header in packet.\n");
} else {
ty->last_audio_pts = ff_parse_pes_pts(
&ty->pes_buffer[es_offset1 + ty->pts_offset]);
pkt->pts = ty->last_audio_pts;
}
ty->pes_buf_cnt = 0;
}
if (av_new_packet(pkt, rec_size - need) < 0)
return AVERROR(ENOMEM);
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size - need);
ty->cur_chunk_pos += rec_size - need;
pkt->stream_index = 1;
/* S2 DTivo has AC3 packets with 2 padding bytes at end. This is
* not allowed in the AC3 spec and will cause problems. So here
* we try to trim things. */
/* Also, S1 DTivo has alternating short / long AC3 packets. That
* is, one packet is short (incomplete) and the next packet has
* the first one's missing data, plus all of its own. Strange. */
if (ty->audio_type == TIVO_AUDIO_AC3 &&
ty->tivo_series == TIVO_SERIES2) {
if (ty->ac3_pkt_size + pkt->size > AC3_PKT_LENGTH) {
pkt->size -= 2;
ty->ac3_pkt_size = 0;
} else {
ty->ac3_pkt_size += pkt->size;
}
}
} else if (subrec_type == 0x03) {
if (av_new_packet(pkt, rec_size) < 0)
return AVERROR(ENOMEM);
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size;
pkt->stream_index = 1;
/* MPEG Audio with PES Header, either SA or DTiVo */
/* ================================================ */
es_offset1 = find_es_header(ty_MPEGAudioPacket, pkt->data, 5);
/* SA PES Header, No Audio Data */
/* ================================================ */
if ((es_offset1 == 0) && (rec_size == 16)) {
ty->last_audio_pts = ff_parse_pes_pts(&pkt->data[SA_PTS_OFFSET]);
if (ty->first_audio_pts == AV_NOPTS_VALUE)
ty->first_audio_pts = ty->last_audio_pts;
av_packet_unref(pkt);
return 0;
}
/* DTiVo Audio with PES Header */
/* ================================================ */
/* Check for complete PES */
if (check_sync_pes(s, pkt, es_offset1, rec_size) == -1) {
/* partial PES header found, nothing else.
* we're done. */
av_packet_unref(pkt);
return 0;
}
} else if (subrec_type == 0x04) {
/* SA Audio with no PES Header */
/* ================================================ */
if (av_new_packet(pkt, rec_size) < 0)
return AVERROR(ENOMEM);
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size;
pkt->stream_index = 1;
pkt->pts = ty->last_audio_pts;
} else if (subrec_type == 0x09) {
if (av_new_packet(pkt, rec_size) < 0)
return AVERROR(ENOMEM);
memcpy(pkt->data, ty->chunk + ty->cur_chunk_pos, rec_size);
ty->cur_chunk_pos += rec_size ;
pkt->stream_index = 1;
/* DTiVo AC3 Audio Data with PES Header */
/* ================================================ */
es_offset1 = find_es_header(ty_AC3AudioPacket, pkt->data, 5);
/* Check for complete PES */
if (check_sync_pes(s, pkt, es_offset1, rec_size) == -1) {
/* partial PES header found, nothing else. we're done. */
av_packet_unref(pkt);
return 0;
}
/* S2 DTivo has invalid long AC3 packets */
if (ty->tivo_series == TIVO_SERIES2) {
if (pkt->size > AC3_PKT_LENGTH) {
pkt->size -= 2;
ty->ac3_pkt_size = 0;
} else {
ty->ac3_pkt_size = pkt->size;
}
}
} else {
/* Unsupported/Unknown */
ty->cur_chunk_pos += rec_size;
return 0;
}
return 1;
}
static int ty_read_packet(AVFormatContext *s, AVPacket *pkt)
{
TYDemuxContext *ty = s->priv_data;
AVIOContext *pb = s->pb;
TyRecHdr *rec;
int64_t rec_size = 0;
int ret = 0;
if (avio_feof(pb))
return AVERROR_EOF;
while (ret <= 0) {
if (!ty->rec_hdrs || ty->first_chunk || ty->cur_rec >= ty->num_recs) {
if (get_chunk(s) < 0 || ty->num_recs <= 0)
return AVERROR_EOF;
}
rec = &ty->rec_hdrs[ty->cur_rec];
rec_size = rec->rec_size;
ty->cur_rec++;
if (rec_size <= 0)
continue;
if (ty->cur_chunk_pos + rec->rec_size > CHUNK_SIZE)
return AVERROR_INVALIDDATA;
if (avio_feof(pb))
return AVERROR_EOF;
switch (rec->rec_type) {
case VIDEO_ID:
ret = demux_video(s, rec, pkt);
break;
case AUDIO_ID:
ret = demux_audio(s, rec, pkt);
break;
default:
ff_dlog(s, "Invalid record type 0x%02x\n", rec->rec_type);
case 0x01:
case 0x02:
case 0x03: /* TiVo data services */
case 0x05: /* unknown, but seen regularly */
ty->cur_chunk_pos += rec->rec_size;
break;
}
}
return 0;
}
static int ty_read_close(AVFormatContext *s)
{
TYDemuxContext *ty = s->priv_data;
av_freep(&ty->seq_table);
av_freep(&ty->rec_hdrs);
return 0;
}
AVInputFormat ff_ty_demuxer = {
.name = "ty",
.long_name = NULL_IF_CONFIG_SMALL("TiVo TY Stream"),
.priv_data_size = sizeof(TYDemuxContext),
.read_probe = ty_probe,
.read_header = ty_read_header,
.read_packet = ty_read_packet,
.read_close = ty_read_close,
.extensions = "ty,ty+",
.flags = AVFMT_TS_DISCONT,
};
Reference in New Issue View Git Blame Copy Permalink