You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
601 lines
14 KiB
601 lines
14 KiB
/*
|
|
* extract_ac3.c
|
|
*
|
|
* Copyright (C) Thomas Oestreich - June 2001
|
|
* Copyright (C) Aaron Holtzman <aholtzma@ess.engr.uvic.ca> - June 1999
|
|
*
|
|
* Ideas and bitstream syntax info borrowed from code written
|
|
* by Nathan Laredo <laredo@gnu.org>
|
|
*
|
|
* Multiple track support by Yuqing Deng <deng@tinker.chem.brown.edu>
|
|
*
|
|
* This file is part of transcode, a video stream processing tool
|
|
*
|
|
* transcode is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* transcode 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GNU Make; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*/
|
|
|
|
#undef DDBUG
|
|
//#define DDBUG
|
|
|
|
#include "transcode.h"
|
|
#include "libtc/libtc.h"
|
|
#include "tcinfo.h"
|
|
|
|
#include <sys/mman.h>
|
|
#include <limits.h>
|
|
|
|
#include "ioaux.h"
|
|
#include "aux_pes.h"
|
|
#include "tc.h"
|
|
|
|
|
|
static unsigned int read_tc_time_stamp(const char *s)
|
|
{
|
|
|
|
unsigned long i, j;
|
|
unsigned long clock_ref=0, clock_ref_ext=0;
|
|
|
|
if(s[0] & 0x40) {
|
|
|
|
i = stream_read_int32(s);
|
|
j = stream_read_int16(s+4);
|
|
|
|
if(i & 0x40000000 || (i >> 28) == 2) {
|
|
clock_ref = ((i & 0x31000000) << 3);
|
|
clock_ref |= ((i & 0x03fff800) << 4);
|
|
clock_ref |= ((i & 0x000003ff) << 5);
|
|
clock_ref |= ((j & 0xf800) >> 11);
|
|
clock_ref_ext = (j >> 1) & 0x1ff;
|
|
}
|
|
}
|
|
|
|
return ((unsigned int) (clock_ref * 300 + clock_ref_ext));
|
|
}
|
|
|
|
|
|
#define BUFFER_SIZE 262144
|
|
static uint8_t *buffer = NULL;
|
|
static FILE *in_file, *out_file;
|
|
|
|
static unsigned int track_code=0, vdr_work_around=0;
|
|
|
|
static int get_pts=0;
|
|
|
|
static subtitle_header_t subtitle_header;
|
|
static char *subtitle_header_str="SUBTITLE";
|
|
|
|
static void pes_ac3_loop (void)
|
|
{
|
|
static int mpeg1_skip_table[16] = {
|
|
1, 0xffff, 5, 10, 0xffff, 0xffff, 0xffff, 0xffff,
|
|
0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
|
|
};
|
|
|
|
uint8_t * buf;
|
|
uint8_t * end;
|
|
uint8_t * tmp1=NULL;
|
|
uint8_t * tmp2=NULL;
|
|
int complain_loudly;
|
|
|
|
char pack_buf[16];
|
|
|
|
unsigned int pack_lpts=0;
|
|
double pack_rpts=0.0f, last_rpts=0.0f, offset_rpts=0.0f, abs_rpts=0.0f;
|
|
double pack_sub_rpts=0.0f, abs_sub_rpts=0.0f;
|
|
|
|
int discont=0;
|
|
|
|
unsigned long i_pts, i_dts;
|
|
|
|
complain_loudly = 1;
|
|
buf = buffer;
|
|
|
|
do {
|
|
end = buf + fread (buf, 1, buffer + BUFFER_SIZE - buf, in_file);
|
|
buf = buffer;
|
|
|
|
//scan buffer
|
|
while (buf + 4 <= end) {
|
|
|
|
// check for valid start code
|
|
if (buf[0] || buf[1] || (buf[2] != 0x01)) {
|
|
if (complain_loudly && (verbose & TC_DEBUG)) {
|
|
tc_log_warn(__FILE__, "missing start code at %#lx",
|
|
ftell (in_file) - (end - buf));
|
|
if ((buf[0] == 0) && (buf[1] == 0) && (buf[2] == 0))
|
|
tc_log_warn(__FILE__, "incorrect zero-byte padding detected - ignored");
|
|
complain_loudly = 0;
|
|
}
|
|
buf++;
|
|
continue;
|
|
}// check for valid start code
|
|
|
|
if(verbose & TC_STATS)
|
|
tc_log_msg(__FILE__, "packet code 0x%x", buf[3]);
|
|
|
|
switch (buf[3]) {
|
|
|
|
case 0xb9: /* program end code */
|
|
return;
|
|
|
|
//check for PTS
|
|
|
|
|
|
case 0xe0: /* video */
|
|
|
|
tmp2 = buf + 6 + (buf[4] << 8) + buf[5];
|
|
|
|
if (tmp2 > end)
|
|
goto copy;
|
|
|
|
if ((buf[6] & 0xc0) == 0x80) {
|
|
/* mpeg2 */
|
|
tmp1 = buf + 9 + buf[8];
|
|
} else {
|
|
/* mpeg1 */
|
|
for (tmp1 = buf + 6; *tmp1 == 0xff; tmp1++)
|
|
if (tmp1 == buf + 6 + 16) {
|
|
tc_log_warn(__FILE__, "too much stuffing");
|
|
buf = tmp2;
|
|
break;
|
|
}
|
|
if ((*tmp1 & 0xc0) == 0x40)
|
|
tmp1 += 2;
|
|
tmp1 += mpeg1_skip_table [*tmp1 >> 4];
|
|
}
|
|
|
|
// get pts time stamp:
|
|
ac_memcpy(pack_buf, &buf[6], 16);
|
|
|
|
if(get_pts_dts(pack_buf, &i_pts, &i_dts)) {
|
|
pack_rpts = (double) i_pts/90000.;
|
|
|
|
if(pack_rpts < last_rpts){ // pts resets when a new chapter begins
|
|
offset_rpts += last_rpts;
|
|
++discont;
|
|
}
|
|
|
|
//default
|
|
last_rpts=pack_rpts;
|
|
abs_rpts=pack_rpts + offset_rpts;
|
|
|
|
//tc_log_msg(__FILE__, "PTS=%8.3f ABS=%8.3f", pack_rpts, abs_rpts);
|
|
}
|
|
|
|
buf = tmp2;
|
|
break;
|
|
|
|
case 0xba: /* pack header */
|
|
|
|
if(get_pts) {
|
|
ac_memcpy(pack_buf, &buf[4], 6);
|
|
pack_lpts = read_tc_time_stamp(pack_buf);
|
|
}
|
|
|
|
/* skip */
|
|
if ((buf[4] & 0xc0) == 0x40) /* mpeg2 */
|
|
tmp1 = buf + 14 + (buf[13] & 7);
|
|
else if ((buf[4] & 0xf0) == 0x20) /* mpeg1 */
|
|
tmp1 = buf + 12;
|
|
else if (buf + 5 > end)
|
|
goto copy;
|
|
else {
|
|
tc_log_error(__FILE__, "weird pack header");
|
|
import_exit(1);
|
|
}
|
|
|
|
if (tmp1 > end)
|
|
goto copy;
|
|
buf = tmp1;
|
|
break;
|
|
|
|
|
|
case 0xbd: /* private stream 1 */
|
|
tmp2 = buf + 6 + (buf[4] << 8) + buf[5];
|
|
if (tmp2 > end)
|
|
goto copy;
|
|
if ((buf[6] & 0xc0) == 0x80) /* mpeg2 */
|
|
tmp1 = buf + 9 + buf[8];
|
|
else { /* mpeg1 */
|
|
for (tmp1 = buf + 6; *tmp1 == 0xff; tmp1++)
|
|
if (tmp1 == buf + 6 + 16) {
|
|
tc_log_warn(__FILE__, "too much stuffing");
|
|
buf = tmp2;
|
|
break;
|
|
}
|
|
if ((*tmp1 & 0xc0) == 0x40)
|
|
tmp1 += 2;
|
|
tmp1 += mpeg1_skip_table [*tmp1 >> 4];
|
|
}
|
|
|
|
if(verbose & TC_STATS)
|
|
tc_log_msg(__FILE__, "track code 0x%x", *tmp1);
|
|
|
|
if(vdr_work_around) {
|
|
if (tmp1 < tmp2) {
|
|
TC_PIPE_WRITE(fileno(out_file), tmp1, tmp2-tmp1);
|
|
/* yeah, I know that's ugly -- FR */
|
|
}
|
|
} else {
|
|
|
|
//subtitle
|
|
|
|
if (*tmp1 == track_code && track_code < 0x40) {
|
|
|
|
if (tmp1 < tmp2) {
|
|
|
|
// get pts time stamp:
|
|
ac_memcpy(pack_buf, &buf[6], 16);
|
|
|
|
if(get_pts_dts(pack_buf, &i_pts, &i_dts)) {
|
|
pack_sub_rpts = (double) i_pts/90000.;
|
|
|
|
//i suppose there *canNOT* be 2 sub chunks from the
|
|
//same sub line over a chapter change
|
|
//let's add the video offset to the subs
|
|
abs_sub_rpts=pack_sub_rpts + offset_rpts;
|
|
|
|
//tc_log_msg(__FILE__, "sub PTS=%8.3f ABS=%8.3f", pack_rpts, abs_rpts);
|
|
}
|
|
|
|
subtitle_header.lpts = pack_lpts;
|
|
subtitle_header.rpts = abs_sub_rpts;
|
|
subtitle_header.discont_ctr = discont;
|
|
subtitle_header.header_version = TC_SUBTITLE_HDRMAGIC;
|
|
subtitle_header.header_length = sizeof(subtitle_header_t);
|
|
subtitle_header.payload_length=tmp2-tmp1;
|
|
|
|
if(verbose & TC_STATS)
|
|
tc_log_msg(__FILE__, "subtitle=0x%x size=%4d lpts=%d rpts=%f rptsfromvid=%f",
|
|
track_code, subtitle_header.payload_length,
|
|
subtitle_header.lpts, subtitle_header.rpts,
|
|
abs_rpts);
|
|
|
|
if(tc_pwrite(STDOUT_FILENO, (uint8_t*) subtitle_header_str, strlen(subtitle_header_str))<0) {
|
|
tc_log_error(__FILE__, "error writing subtitle: %s",
|
|
strerror(errno));
|
|
import_exit(1);
|
|
}
|
|
if(tc_pwrite(STDOUT_FILENO, (uint8_t*) &subtitle_header, sizeof(subtitle_header_t))<0) {
|
|
tc_log_error(__FILE__, "error writing subtitle: %s",
|
|
strerror(errno));
|
|
import_exit(1);
|
|
}
|
|
if(tc_pwrite(STDOUT_FILENO, tmp1, tmp2-tmp1)<0) {
|
|
tc_log_error(__FILE__, "error writing subtitle: %s",
|
|
strerror(errno));
|
|
import_exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
//ac3 package
|
|
|
|
if (*tmp1 == track_code && track_code >= 0x80) {
|
|
tmp1 += 4;
|
|
#if 0
|
|
//test
|
|
if(0) {
|
|
ac_memcpy(pack_buf, &buf[6], 16);
|
|
get_pts_dts(pack_buf, &i_pts, &i_dts);
|
|
tc_log_msg(__FILE__, "AC3 PTS=%f", (double) i_pts/90000.);
|
|
}
|
|
#endif
|
|
if (tmp1 < tmp2) {
|
|
TC_PIPE_WRITE(fileno(out_file), tmp1, tmp2-tmp1);
|
|
/* yeah, I know that's ugly -- FR */
|
|
}
|
|
}
|
|
}
|
|
|
|
buf = tmp2;
|
|
break;
|
|
|
|
default:
|
|
if (buf[3] < 0xb9)
|
|
tc_log_warn(__FILE__, "broken stream - skipping data");
|
|
|
|
/* skip */
|
|
tmp1 = buf + 6 + (buf[4] << 8) + buf[5];
|
|
if (tmp1 > end)
|
|
goto copy;
|
|
buf = tmp1;
|
|
break;
|
|
|
|
} //start code selection
|
|
} //scan buffer
|
|
|
|
if (buf < end) {
|
|
copy:
|
|
/* we only pass here for mpeg1 ps streams */
|
|
memmove (buffer, buf, end - buf);
|
|
}
|
|
buf = buffer + (end - buf);
|
|
|
|
} while (end == buffer + BUFFER_SIZE);
|
|
}
|
|
|
|
|
|
|
|
|
|
FILE *fd;
|
|
|
|
#define MAX_BUF 4096
|
|
char audio[MAX_BUF];
|
|
|
|
|
|
/* from ac3scan.c */
|
|
static int get_ac3_bitrate(uint8_t *ptr)
|
|
{
|
|
static const int bitrates[] = {
|
|
32, 40, 48, 56,
|
|
64, 80, 96, 112,
|
|
128, 160, 192, 224,
|
|
256, 320, 384, 448,
|
|
512, 576, 640
|
|
};
|
|
int ratecode = (ptr[2] & 0x3E) >> 1;
|
|
if (ratecode < sizeof(bitrates)/sizeof(*bitrates))
|
|
return bitrates[ratecode];
|
|
return -1;
|
|
}
|
|
|
|
static int get_ac3_samplerate(uint8_t *ptr)
|
|
{
|
|
static const int samplerates[] = {48000, 44100, 32000, -1};
|
|
return samplerates[ptr[2]>>6];
|
|
}
|
|
|
|
static int get_ac3_framesize(uint8_t *ptr)
|
|
{
|
|
int bitrate = get_ac3_bitrate(ptr);
|
|
int samplerate = get_ac3_samplerate(ptr);
|
|
if (bitrate < 0 || samplerate < 0)
|
|
return -1;
|
|
return bitrate * 96000 / samplerate + (samplerate==44100 ? ptr[2]&1 : 0);
|
|
}
|
|
|
|
|
|
static int ac3scan(int infd, int outfd)
|
|
{
|
|
int pseudo_frame_size = 0, j = 0, i = 0, s = 0;
|
|
unsigned long k = 0;
|
|
#ifdef DDBUG
|
|
int n = 0;
|
|
#endif
|
|
char buffer[SIZE_PCM_FRAME];
|
|
int frame_size, bitrate;
|
|
float rbytes;
|
|
uint16_t sync_word = 0;
|
|
ssize_t bytes_read;
|
|
|
|
// need to find syncframe:
|
|
for (;;) {
|
|
k = 0;
|
|
for (;;) {
|
|
bytes_read = tc_pread(infd, &buffer[s], 1);
|
|
if (bytes_read <= 0) {
|
|
// ac3 sync frame scan failed
|
|
if (bytes_read == 0) /* EOF */
|
|
return 0;
|
|
else
|
|
return ERROR_INVALID_HEADER;
|
|
}
|
|
|
|
sync_word = (sync_word << 8) + (uint8_t) buffer[s];
|
|
|
|
s = (s + 1) % 2;
|
|
++i;
|
|
++k;
|
|
|
|
if (sync_word == 0x0b77) {
|
|
break;
|
|
}
|
|
|
|
if (k > (1 << 20)) {
|
|
tc_log_error(__FILE__, "no AC3 sync frame found within 1024 kB of stream");
|
|
return 1;
|
|
}
|
|
}
|
|
i = i - 2;
|
|
#ifdef DDBUG
|
|
tc_log_msg(__FILE__, "found sync frame at offset %d (%d)", i, j);
|
|
#endif
|
|
// read rest of header
|
|
if (tc_pread(infd, &buffer[2], 3) !=3) {
|
|
return ERROR_INVALID_HEADER;
|
|
}
|
|
|
|
if ((frame_size = 2 * get_ac3_framesize(&buffer[2])) < 1) {
|
|
tc_log_error(__FILE__, "ac3 framesize %d invalid", frame_size);
|
|
return 1;
|
|
}
|
|
|
|
//FIXME: I assume that a single AC3 frame contains 6kB PCM bytes
|
|
|
|
rbytes = (float) SIZE_PCM_FRAME/1024/6 * frame_size;
|
|
pseudo_frame_size = (int) rbytes;
|
|
|
|
if ((bitrate = get_ac3_bitrate(&buffer[2])) < 1) {
|
|
tc_log_error(__FILE__, "ac3 bitrate invalid");
|
|
return 1;
|
|
}
|
|
|
|
// write out frame header
|
|
|
|
#ifdef DDBUG
|
|
tc_log_msg(__FILE__, "[%05d] %04d bytes, pcm pseudo frame %04d bytes, bitrate %03d kBits/s",
|
|
n++, frame_size, pseudo_frame_size, bitrate);
|
|
#endif
|
|
|
|
// s points directly at first byte of syncword
|
|
tc_pwrite(outfd, &buffer[s], 1);
|
|
s = (s + 1) % 2;
|
|
tc_pwrite(outfd, &buffer[s], 1);
|
|
s = (s + 1) % 2;
|
|
|
|
// read packet
|
|
tc_pread(infd, &buffer[5], frame_size-5);
|
|
tc_pwrite(outfd, &buffer[2], frame_size-2);
|
|
|
|
i += frame_size;
|
|
j = i;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------
|
|
*
|
|
* extract thread
|
|
*
|
|
* magic: TC_MAGIC_VOB
|
|
* TC_MAGIC_AVI
|
|
* TC_MAGIC_RAW <-- default
|
|
*
|
|
* ------------------------------------------------------------*/
|
|
|
|
|
|
void extract_ac3(info_t *ipipe)
|
|
{
|
|
|
|
int error=0;
|
|
|
|
avi_t *avifile;
|
|
|
|
long frames, bytes, padding, n;
|
|
|
|
verbose = ipipe->verbose;
|
|
|
|
buffer = tc_malloc (BUFFER_SIZE);
|
|
|
|
switch(ipipe->magic) {
|
|
|
|
case TC_MAGIC_VDR:
|
|
|
|
in_file = fdopen(ipipe->fd_in, "r");
|
|
out_file = fdopen(ipipe->fd_out, "w");
|
|
|
|
vdr_work_around=1;
|
|
|
|
pes_ac3_loop();
|
|
|
|
fclose(in_file);
|
|
fclose(out_file);
|
|
|
|
break;
|
|
|
|
case TC_MAGIC_VOB:
|
|
|
|
in_file = fdopen(ipipe->fd_in, "r");
|
|
out_file = fdopen(ipipe->fd_out, "w");
|
|
|
|
|
|
if(ipipe->codec==TC_CODEC_PS1) {
|
|
|
|
track_code = ipipe->track;
|
|
get_pts=1;
|
|
|
|
if(track_code < 0) import_exit(1);
|
|
|
|
} else {
|
|
if (ipipe->track < 0 || ipipe->track >= TC_MAX_AUD_TRACKS) {
|
|
tc_log_error(__FILE__, "invalid track number: %d", ipipe->track);
|
|
import_exit(1);
|
|
}
|
|
|
|
// DTS tracks begin with ID 0x88, ac3 with 0x80
|
|
if (ipipe->codec == TC_CODEC_DTS)
|
|
track_code = ipipe->track + 0x88;
|
|
else
|
|
track_code = ipipe->track + 0x80;
|
|
}
|
|
|
|
pes_ac3_loop();
|
|
|
|
fclose(in_file);
|
|
fclose(out_file);
|
|
|
|
break;
|
|
|
|
|
|
case TC_MAGIC_AVI:
|
|
|
|
if(ipipe->stype == TC_STYPE_STDIN){
|
|
tc_log_error(__FILE__, "invalid magic/stype - exit");
|
|
error=1;
|
|
break;
|
|
}
|
|
|
|
// scan file
|
|
if (ipipe->nav_seek_file) {
|
|
if(NULL == (avifile = AVI_open_indexfd(ipipe->fd_in,0,ipipe->nav_seek_file))) {
|
|
AVI_print_error("AVI open");
|
|
break;
|
|
}
|
|
} else {
|
|
if(NULL == (avifile = AVI_open_fd(ipipe->fd_in,1))) {
|
|
AVI_print_error("AVI open");
|
|
break;
|
|
}
|
|
}
|
|
|
|
//set selected for multi-audio AVI-files
|
|
AVI_set_audio_track(avifile, ipipe->track);
|
|
|
|
// get total audio size
|
|
bytes = AVI_audio_bytes(avifile);
|
|
|
|
padding = bytes % MAX_BUF;
|
|
frames = bytes / MAX_BUF;
|
|
|
|
for (n=0; n<frames; ++n) {
|
|
|
|
if(AVI_read_audio(avifile, audio, MAX_BUF)<0) {
|
|
error=1;
|
|
break;
|
|
}
|
|
|
|
if(tc_pwrite(ipipe->fd_out, audio, MAX_BUF)!= MAX_BUF) {
|
|
error=1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if((bytes = AVI_read_audio(avifile, audio, padding)) < padding)
|
|
error=1;
|
|
|
|
if(tc_pwrite(ipipe->fd_out, audio, bytes)!= bytes) error=1;
|
|
|
|
break;
|
|
|
|
case TC_MAGIC_RAW:
|
|
default:
|
|
|
|
if(ipipe->magic == TC_MAGIC_UNKNOWN)
|
|
tc_log_warn(__FILE__, "no file type specified, assuming %s",
|
|
filetype(TC_MAGIC_RAW));
|
|
|
|
error=ac3scan(ipipe->fd_in, ipipe->fd_out);
|
|
break;
|
|
}
|
|
|
|
free (buffer);
|
|
import_exit(error);
|
|
|
|
}
|
|
|