mplayer.hg: libmpdemux/demux

comparison libmpdemux/demux_ty.c @ 24487:f364db0d1067

Remove tabs and trailing whitespace

author	reimar
date	Fri, 14 Sep 2007 20:59:05 +0000
parents	20a8ee3f041a
children	d6c49e8a8046

comparison

equal deleted inserted replaced

-:20a8ee3f041a
+:f364db0d1067
 *
 * Copyright (C) 2003 Christopher R. Wingert
 *
 * The license covers the portions of this file regarding TiVo additions.
 *
 * Olaf Beck and Tridge (indirectly) were essential at providing
 * information regarding the format of the TiVo streams.
 *
 * However, no code in the following subsection is directly copied from
 * either author.
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 // 8/e0: video I-frame header start
 // a/e0: video P-frame header start
 // b/e0: video B-frame header start
 // c/e0: video GOP header start
 // e/01: closed-caption data
 // e/02: Extended data services data
 #define TIVO_PES_FILEID   0xf5467abd
 #define TIVO_PART_LENGTH  0x20000000
 int64_t        lastVideoPTS;
 int             headerOk;
 off_t           size;
 int             readHeader;
 int             tmf;
 tmf_fileParts   tmfparts[ MAX_TMF_PARTS ];
 int             tmf_totalparts;
 } TiVoInfo;
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "Dumping tar contents\n" );
 while (1)
 {
 if (!stream_seek(demux->stream, offset))
 {
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "Seek bad %"PRId64"\n", (int64_t)offset );
 break;
 }
 if (stream_read(demux->stream, header, 512) < 512)
 {
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "Read bad\n" );
 break;
 }
 name = header;
 name[99] = 0;
 if ( offset + skip > totalsize )
 size = totalsize - offset;
 isty = ty_extensionis( name, ".ty" );
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "name %-20.20s size %-12.12s %d %d\n",
 name, sizestr, size, isty );
 if ( isty )
 {
 if ( parts >= MAX_TMF_PARTS ) {
 tivo->tmfparts[ parts ].fileNo = parts;
 tivo->tmfparts[ parts ].fileSize = size;
 tivo->tmfparts[ parts ].startOffset = offset + 512;
 tivo->tmfparts[ parts ].chunks = size / CHUNKSIZE;
 mp_msg
 (
 MSGT_DEMUX, MSGL_DBG3,
 "tmf_filetoparts(): index %d, file %d, chunks %d\n",
 parts,
 tivo->tmfparts[ parts ].fileNo,
 tivo->tmfparts[ parts ].chunks
 );
 mp_msg
 (
 MSGT_DEMUX, MSGL_DBG3,
 "tmf_filetoparts(): size %"PRId64"\n",
 tivo->tmfparts[ parts ].fileSize
 );
 mp_msg
 (
 MSGT_DEMUX, MSGL_DBG3,
 "tmf_filetoparts(): startOffset %"PRId64"\n",
 tivo->tmfparts[ parts ].startOffset
 );
 parts++;
 return -1;
 }
 // ===========================================================================
 static int tmf_load_chunk( demuxer_t *demux, TiVoInfo *tivo,
 unsigned char *buff, int size, int readChunk )
 {
 off_t fileoffset;
 int    count;
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "\ntmf_load_chunk() begin %d\n",
 readChunk );
 fileoffset = tmf_filetooffset(tivo, readChunk);
 if (fileoffset == -1) {
 {
 mp_msg( MSGT_DEMUX, MSGL_ERR, "Read past EOF()\n" );
 return 0;
 }
 count = stream_read( demux->stream, buff, size );
-	demux->filepos = stream_tell( demux->stream );
+demux->filepos = stream_tell( demux->stream );
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "tmf_load_chunk() count %x\n",
-		count );
+count );
 mp_msg( MSGT_DEMUX, MSGL_DBG3,
-		"tmf_load_chunk() bytes %x %x %x %x %x %x %x %x\n",
+"tmf_load_chunk() bytes %x %x %x %x %x %x %x %x\n",
-		buff[ 0 ], buff[ 1 ], buff[ 2 ], buff[ 3 ],
+buff[ 0 ], buff[ 1 ], buff[ 2 ], buff[ 3 ],
-		buff[ 4 ], buff[ 5 ], buff[ 6 ], buff[ 7 ] );
+buff[ 4 ], buff[ 5 ], buff[ 6 ], buff[ 7 ] );
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "tmf_load_chunk() end\n" );
 return count;
 }
 // ===========================================================================
 {
 *ptsOffset = SERIES2_PTS_OFFSET;
 *ptsLen = SERIES2_PTS_LENGTH;
 return 1;
 }
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "ty:Tossing Audio Packet Size %d\n",
 size );
 return 0;
 }
 return MP_NOPTS_VALUE;
 a >>= 1; b >>= 1; c >>= 1;
 return (((uint64_t)a) << 30) | (b << 15) | c;
 }
 static void demux_ty_AddToAudioBuffer( TiVoInfo *tivo, unsigned char *buffer,
 int size )
 {
 if ( tivo->lastAudioEnd + size < MAX_AUDIO_BUFFER )
 {
 memcpy( &tivo->lastAudio[ tivo->lastAudioEnd ],
 buffer, size );
 tivo->lastAudioEnd += size;
 }
 else
 mp_msg( MSGT_DEMUX, MSGL_ERR,
 "ty:WARNING - Would have blown my audio buffer\n" );
 }
 static void demux_ty_CopyToDemuxPacket( int type, TiVoInfo *tivo, demux_stream_t *ds,
-	unsigned char *buffer, int size, off_t pos, float pts )
+unsigned char *buffer, int size, off_t pos, float pts )
 {
 demux_packet_t *dp = new_demux_packet( size );
 memcpy( dp->buffer, buffer, size );
 if (pts != MP_NOPTS_VALUE)
 dp->pts = pts / 90000.0;
 dp->pos = pos;
 dp->flags = 0;
 ds_add_packet( ds, dp );
-	if ( type == TY_V  && tivo->firstVideoPTS == MP_NOPTS_VALUE )
+if ( type == TY_V  && tivo->firstVideoPTS == MP_NOPTS_VALUE )
-			tivo->firstVideoPTS = pts;
+tivo->firstVideoPTS = pts;
-	if ( type == TY_A && tivo->firstAudioPTS == MP_NOPTS_VALUE )
+if ( type == TY_A && tivo->firstAudioPTS == MP_NOPTS_VALUE )
-			tivo->firstAudioPTS = pts;
+tivo->firstAudioPTS = pts;
 }
 static int demux_ty_FindESHeader( uint8_t nal,
 unsigned char *buffer, int bufferSize )
 {
 return p - buffer - 4;
 }
 return -1;
 }
 static void demux_ty_FindESPacket( uint8_t nal,
 unsigned char *buffer, int bufferSize, int *esOffset1, int *esOffset2 )
 {
 *esOffset1 = demux_ty_FindESHeader(nal, buffer, bufferSize);
 if (*esOffset1 == -1) {
 *esOffset2 = -1;
 int              offset;
 int              counter;
 int              aid;
 TiVoInfo         *tivo = demux->priv;
 if ( demux->stream->type == STREAMTYPE_DVD )
-		return 0;
+return 0;
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "ty:ty processing\n" );
 if( demux->stream->eof ) return 0;
 // ======================================================================
 // If we haven't figured out the size of the stream, let's do so
 // ======================================================================
 #ifdef STREAMTYPE_STREAM_TY
 if ( demux->stream->type == STREAMTYPE_STREAM_TY )
 if ( readSize == CHUNKSIZE && AV_RB32(chunk) == TIVO_PES_FILEID )
 {
 off_t numberParts;
 readSize = 0;
 if ( tivo->tmf != 1 )
 {
 off_t offset;
 numberParts = demux->stream->end_pos / TIVO_PART_LENGTH;
 }
 else
 {
 numberParts = tivo->tmf_totalparts;
 offset = numberParts * TIVO_PART_LENGTH;
 readSize = tmf_load_chunk( demux, tivo, chunk, CHUNKSIZE,
 numberParts * ( TIVO_PART_LENGTH - CHUNKSIZE ) /
 CHUNKSIZE );
 }
 if ( readSize == CHUNKSIZE && AV_RB32(chunk) == TIVO_PES_FILEID )
 {
 int size = AV_RB24(chunk + 12);
 size -= 4;
 size *= CHUNKSIZE;
 tivo->size = numberParts * TIVO_PART_LENGTH;
 tivo->size += size;
 mp_msg( MSGT_DEMUX, MSGL_DBG3,
 "ty:Header Calc Stream Size %"PRId64"\n", tivo->size );
 }
 }
 if ( tivo->size > demux->stream->end_pos )
 tivo->size = demux->stream->end_pos;
-			if ( demux->stream->start_pos > 0 )
+if ( demux->stream->start_pos > 0 )
-				filePos = demux->stream->start_pos;
+filePos = demux->stream->start_pos;
 stream_seek( demux->stream, filePos );
-			demux->filepos = stream_tell( demux->stream );
+demux->filepos = stream_tell( demux->stream );
 tivo->whichChunk = filePos / CHUNKSIZE;
 }
 demux->movi_start = 0;
 demux->movi_end = tivo->size;
 }
 if ( readSize != CHUNKSIZE )
 return 0;
 }
 else
 {
 readSize = tmf_load_chunk( demux, tivo, chunk, CHUNKSIZE,
 tivo->whichChunk );
 if ( readSize != CHUNKSIZE )
 return 0;
 tivo->whichChunk++;
 }
 demux->filepos = stream_tell( demux->stream );
 readSize = stream_read( demux->stream, chunk, CHUNKSIZE );
 }
 else
 {
 readSize = tmf_load_chunk( demux, tivo, chunk, CHUNKSIZE,
 tivo->whichChunk );
 tivo->whichChunk++;
 }
 if ( readSize != CHUNKSIZE )
 return 0;
 }
 mp_msg( MSGT_DEMUX, MSGL_DBG3,
 "\nty:actual current offset %"PRIx64"\n", stream_tell( demux->stream ) -
-		CHUNKSIZE );
+CHUNKSIZE );
 // Let's make a Video Demux Stream for MPlayer
 aid = 0x0;
 if( !demux->v_streams[ aid ] ) new_sh_video( demux, aid );
 // ================================================================
 if ( type == 0xe0 )
 {
 if ( size > 0 && size + offset <= CHUNKSIZE )
 {
 int esOffset1 = demux_ty_FindESHeader( VIDEO_NAL, &chunk[ offset ],
 size);
 if ( esOffset1 != -1 )
 tivo->lastVideoPTS = get_ty_pts(
 &chunk[ offset + esOffset1 + 9 ] );
 // Do NOT Pass the PES Header onto the MPEG2 Decode
 if( nybbleType != 0x06 )
 demux_ty_CopyToDemuxPacket( TY_V, tivo, demux->video,
-						&chunk[ offset ], size, demux->filepos + offset,
+&chunk[ offset ], size, demux->filepos + offset,
-						tivo->lastVideoPTS );
+tivo->lastVideoPTS );
 offset += size;
 }
-			else
+else
-				errorHeader++;
+errorHeader++;
 }
 // ================================================================
 // Audio Parsing
 // ================================================================
-		else if ( type == 0xc0 )
+else if ( type == 0xc0 )
 {
 if ( size > 0 && size + offset <= CHUNKSIZE )
 {
 if( demux->audio->id == -1 )
 {
 else
 {
 mp_msg( MSGT_DEMUX, MSGL_DBG3,
 "ty:Adding Audio Packet Size %d\n", size );
 demux_ty_CopyToDemuxPacket( TY_A, tivo, demux->audio,
-							&chunk[ offset ], size, ( demux->filepos + offset ),
+&chunk[ offset ], size, ( demux->filepos + offset ),
-							tivo->lastAudioPTS );
+tivo->lastAudioPTS );
 }
 }
 // 3 - MPEG Audio with PES Header, either SA or DTiVo
 // 9 - DTiVo AC3 Audio Data with PES Header
 // ================================================
 if ( nybbleType == 0x03 || nybbleType == 0x09 )
 {
 int esOffset1, esOffset2;
 if ( nybbleType == 0x03 )
 esOffset1 = demux_ty_FindESHeader( AUDIO_NAL, &chunk[ offset ],
 size);
 // SA PES Header, No Audio Data
 // ================================================
 if ( nybbleType == 0x03 && esOffset1 == 0 && size == 16 )
 {
 tivo->tivoType = 1;
 tivo->lastAudioPTS = get_ty_pts( &chunk[ offset +
 SERIES2_PTS_OFFSET ] );
 }
 else
 // DTiVo Audio with PES Header
 // ================================================
 {
 int packetSize = esOffset2 - esOffset1;
 int headerSize;
 int ptsOffset;
 if ( IsValidAudioPacket( packetSize, &ptsOffset,
 &headerSize ) )
 {
 mp_msg( MSGT_DEMUX, MSGL_DBG3,
 "ty:Adding DTiVo Audio Packet Size %d\n",
 packetSize );
 tivo->lastAudioPTS = get_ty_pts(
 &tivo->lastAudio[ esOffset1 + ptsOffset ] );
 if (nybbleType == 9) headerSize = 0;
 demux_ty_CopyToDemuxPacket
 (
-								   TY_A,
+TY_A,
-								   tivo,
+tivo,
 demux->audio,
 &tivo->lastAudio[ esOffset1 + headerSize ],
 packetSize - headerSize,
 demux->filepos + offset,
 tivo->lastAudioPTS
 );
 }
 // Collapse the Audio Buffer
 tivo->lastAudioEnd -= esOffset2;
 memmove( &tivo->lastAudio[ 0 ],
 &tivo->lastAudio[ esOffset2 ],
 tivo->lastAudioEnd );
 }
 }
 }
 offset += size;
 }
-			else
+else
-				errorHeader++;
+errorHeader++;
-		}
+}
 // ================================================================
 // 1 = Closed Caption
 // 2 = Extended Data Services
 // ================================================================
-		else if ( type == 0x01 || type == 0x02 )
+else if ( type == 0x01 || type == 0x02 )
-		{
+{
 unsigned char lastXDS[ 16 ];
-			int b = AV_RB24(recPtr) >> 4;
+int b = AV_RB24(recPtr) >> 4;
-			b &= 0x7f7f;
+b &= 0x7f7f;
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "ty:%s %04x\n", type == 1 ? "CC" : "XDS", b);
-			lastXDS[ 0x00 ] = 0x00;
+lastXDS[ 0x00 ] = 0x00;
-			lastXDS[ 0x01 ] = 0x00;
+lastXDS[ 0x01 ] = 0x00;
-			lastXDS[ 0x02 ] = 0x01;
+lastXDS[ 0x02 ] = 0x01;
-			lastXDS[ 0x03 ] = 0xb2;
+lastXDS[ 0x03 ] = 0xb2;
-			lastXDS[ 0x04 ] = 'T';
+lastXDS[ 0x04 ] = 'T';
-			lastXDS[ 0x05 ] = 'Y';
+lastXDS[ 0x05 ] = 'Y';
-			lastXDS[ 0x06 ] = type;
+lastXDS[ 0x06 ] = type;
-			lastXDS[ 0x07 ] = b >> 8;
+lastXDS[ 0x07 ] = b >> 8;
-			lastXDS[ 0x08 ] = b;
+lastXDS[ 0x08 ] = b;
 if ( subcc_enabled )
-			   demux_ty_CopyToDemuxPacket( TY_V, tivo, demux->video, lastXDS, 0x09,
+demux_ty_CopyToDemuxPacket( TY_V, tivo, demux->video, lastXDS, 0x09,
-				   demux->filepos + offset, tivo->lastVideoPTS );
+demux->filepos + offset, tivo->lastVideoPTS );
-		}
+}
 // ================================================================
 // Unknown
 // ================================================================
-		else
+else
-		{
+{
 if ( size > 0 && size + offset <= CHUNKSIZE )
 offset += size;
 if (type != 3 && type != 5) {
 mp_msg( MSGT_DEMUX, MSGL_DBG3, "ty:Invalid Type %x\n", type );
-			invalidType++;
+invalidType++;
 }
-		}
+}
 recPtr += 16;
 }
 if ( errorHeader > 0 || invalidType > 0 )
 {
 mp_msg( MSGT_DEMUX, MSGL_DBG3,
 "ty:Error Check - Records %d, Parsed %d, Errors %d + %d\n",
 numberRecs, recordsDecoded, errorHeader, invalidType );
 // Invalid MPEG ES Size Check
 if ( errorHeader > numberRecs / 2 )
 //
 //================= seek in MPEG ==========================
 demuxer->filepos = stream_tell( demuxer->stream );
 newpos = ( flags & 1 ) ? demuxer->movi_start : demuxer->filepos;
 if( flags & 2 )
-	   // float seek 0..1
+// float seek 0..1
-	   newpos += ( demuxer->movi_end - demuxer->movi_start ) * rel_seek_secs;
+newpos += ( demuxer->movi_end - demuxer->movi_start ) * rel_seek_secs;
 else
 {
-	   // time seek (secs)
+// time seek (secs)
 if( ! sh_video->i_bps ) // unspecified or VBR
 newpos += 2324 * 75 * rel_seek_secs; // 174.3 kbyte/sec
 else
 newpos += sh_video->i_bps * rel_seek_secs;
 }
 if ( newpos < demuxer->movi_start )
 {
-	   if( demuxer->stream->type != STREAMTYPE_VCD ) demuxer->movi_start = 0;
+if( demuxer->stream->type != STREAMTYPE_VCD ) demuxer->movi_start = 0;
-	   if( newpos < demuxer->movi_start ) newpos = demuxer->movi_start;
+if( newpos < demuxer->movi_start ) newpos = demuxer->movi_start;
-	}
+}
 res = newpos / CHUNKSIZE;
 if ( rel_seek_secs >= 0 )
 newpos = ( res + 1 ) * CHUNKSIZE;
 else
 stream_seek( demuxer->stream, newpos );
 // re-sync video:
 videobuf_code_len = 0; // reset ES stream buffer
-	ds_fill_buffer( d_video );
+ds_fill_buffer( d_video );
-	if( sh_audio )
+if( sh_audio )
-	  ds_fill_buffer( d_audio );
+ds_fill_buffer( d_audio );
-	while( 1 )
+while( 1 )
 {
-	  int i;
+int i;
 if( sh_audio && !d_audio->eof && d_video->pts && d_audio->pts )
 {
-	     float a_pts = d_audio->pts;
+float a_pts = d_audio->pts;
 a_pts += ( ds_tell_pts( d_audio ) - sh_audio->a_in_buffer_len ) /
 (float)sh_audio->i_bps;
-	     if( d_video->pts > a_pts )
+if( d_video->pts > a_pts )
 {
-	        skip_audio_frame( sh_audio );  // sync audio
+skip_audio_frame( sh_audio );  // sync audio
-	        continue;
+continue;
-	     }
+}
 }
 i = sync_video_packet( d_video );
 if( i == 0x1B3 || i == 0x1B8 ) break; // found it!
 if( !i || !skip_video_packet( d_video ) ) break; // EOF?
 }
-	if ( subcc_enabled )
+if ( subcc_enabled )
-	   ty_ClearOSD( 0 );
+ty_ClearOSD( 0 );
 }
 static int demux_ty_control( demuxer_t *demuxer,int cmd, void *arg )
 {
 demux_stream_t *d_video = demuxer->video;
 sh_video_t     *sh_video = d_video->sh;
 switch(cmd)
 {
-	   case DEMUXER_CTRL_GET_TIME_LENGTH:
+case DEMUXER_CTRL_GET_TIME_LENGTH:
-	      if(!sh_video->i_bps)  // unspecified or VBR
+if(!sh_video->i_bps)  // unspecified or VBR
-		   return DEMUXER_CTRL_DONTKNOW;
+return DEMUXER_CTRL_DONTKNOW;
-	      *(double *)arg=
+*(double *)arg=
 (double)demuxer->movi_end-demuxer->movi_start/sh_video->i_bps;
-	      return DEMUXER_CTRL_GUESS;
+return DEMUXER_CTRL_GUESS;
-	   case DEMUXER_CTRL_GET_PERCENT_POS:
+case DEMUXER_CTRL_GET_PERCENT_POS:
-		   return DEMUXER_CTRL_DONTKNOW;
+return DEMUXER_CTRL_DONTKNOW;
-	    default:
+default:
-	       return DEMUXER_CTRL_NOTIMPL;
+return DEMUXER_CTRL_NOTIMPL;
 }
 }
 static void demux_close_ty( demuxer_t *demux )
 {
 TiVoInfo         *tivo = demux->priv;
 free( tivo );
-	   sub_justify = 0;
+sub_justify = 0;
 }
 static int ty_check_file(demuxer_t* demuxer)
 {

Mercurial > mplayer.hg

comparison libmpdemux/demux_ty.c @ 24487:f364db0d1067