mirror
/
F5OEO-tstools
kopia lustrzana https://github.com/F5OEO/tstools
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
F5OEO-tstools/es2ts.c

458 wiersze
13 KiB
C
Czysty Bezpośredni odnośnik Wina Historia

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

/*
* Convert an Elementary Stream to Transport Stream.
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the MPEG TS, PS and ES tools.
*
* The Initial Developer of the Original Code is Amino Communications Ltd.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Amino Communications Ltd, Swavesey, Cambridge UK
*
* ***** END LICENSE BLOCK *****
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#ifdef _WIN32
#include <stddef.h>
#else // _WIN32
#include <unistd.h>
#endif // _WIN32
#include "compat.h"
#include "es_fns.h"
#include "ts_fns.h"
#include "tswrite_fns.h"
#include "misc_fns.h"
#include "printing_fns.h"
#include "version.h"
/*
* Write (copy) the current ES data unit to the output stream, wrapped up in a
* PES within TS.
*
* Returns 0 if all went well, 1 if something went wrong.
*/
static int write_ES_unit_as_TS(TS_writer_p output,
ES_unit_p unit,
uint32_t video_pid)
{
int err = write_ES_as_TS_PES_packet(output,unit->data,unit->data_len,
video_pid,DEFAULT_VIDEO_STREAM_ID);
if (err)
{
print_err("### Error writing ES data unit\n");
return err;
}
else
return 0;
}
static int transfer_data(ES_p es,
TS_writer_p output,
uint32_t pmt_pid,
uint32_t video_pid,
byte stream_type,
int max,
int verbose,
int quiet)
{
int err = 0;
int count = 0;
// Write out a PAT and PMT first, or our stream won't make sense
if (!quiet)
fprint_msg("Using transport stream id 1, PMT PID %#x, program 1 ="
" PID %#x, stream type %#x\n",pmt_pid,video_pid,
stream_type);
err = write_TS_program_data(output,1,1,pmt_pid,video_pid,stream_type);
if (err)
{
print_err("### Error writing out TS program data\n");
return 1;
}
for (;;)
{
ES_unit_p unit;
err = find_and_build_next_ES_unit(es,&unit);
if (err == EOF)
break;
else if (err)
{
print_err("### Error copying ES data units\n");
return err;
}
count++;
if (verbose)
report_ES_unit(FALSE,unit);
err = write_ES_unit_as_TS(output,unit,video_pid);
if (err)
{
free_ES_unit(&unit);
print_err("### Error copying ES data units\n");
return err;
}
free_ES_unit(&unit);
if (max > 0 && count >= max)
break;
}
if (!quiet)
fprint_msg("Transferred %d ES data unit%s\n",count,(count==1?"":"s"));
return 0;
}
static void print_usage()
{
print_msg( "Usage: es2ts [switches] [<infile>] [<outfile>]\n"
"\n"
);
REPORT_VERSION("es2ts");
print_msg(
"\n"
" Convert an elementary video stream to H.222 transport stream.\n"
" Supports input streams conforming to MPEG-2 (H.262), MPEG-4/AVC\n"
" (H.264) and AVS. Also supports MPEG-1 input streams, insofar as MPEG-2\n"
" is backwards compatible with MPEG-1.\n"
"\n"
" Note that this program works by reading and packaging the elementary\n"
" stream packages directly - it does not parse them as H.262 or H.264\n"
" data.\n"
"\n"
"Files:\n"
" <infile> is a file containing the Elementary Stream data\n"
" (but see -stdin below)\n"
" <outfile> is an H.222 Transport Stream file\n"
" (but see -stdout and -host below)\n"
"\n"
"Switches:\n"
" -pid <pid> <pid> is the video PID to use for the data.\n"
" Use '-pid 0x<pid>' to specify a hex value.\n"
" Defaults to 0x68.\n"
" -pmt <pid> <pid> is the PMT PID to use.\n"
" Use '-pmt 0x<pid>' to specify a hex value.\n"
" Defaults to 0x66\n"
" -verbose, -v Output summary information about each ES packet\n"
" as it is read\n"
" -quiet, -q Only output error messages\n"
" -err stdout Write error messages to standard output (the default)\n"
" -err stderr Write error messages to standard error (Unix traditional)\n"
" -stdin Take input from <stdin>, instead of a named file\n"
" -stdout Write output to <stdout>, instead of a named file\n"
" Forces -quiet and -err stderr.\n"
" -host <host>, -host <host>:<port>\n"
" Writes output (over TCP/IP) to the named <host>,\n"
" instead of to a named file. If <port> is not\n"
" specified, it defaults to 88.\n"
" -max <n>, -m <n> Maximum number of ES data units to read\n"
"\n"
"Stream type:\n"
" When the TS data is being output, it is flagged to indicate whether\n"
" it conforms to H.262, H.264 or AVS. It is important to get this right,\n"
" as it will affect interpretation of the TS data.\n"
"\n"
" If input is from a file, then the program will look at the start of\n"
" the file to determine if the stream is H.264, H.262 or AVS. This\n"
" process may occasionally come to the wrong conclusion, in which case\n"
" the user can override the choice using the following switches.\n"
"\n"
" If input is from standard input (via -stdin), then it is not possible\n"
" for the program to make its own decision on the input stream type.\n"
" Instead, it defaults to H.262, and relies on the user indicating if\n"
" this is wrong.\n"
"\n"
" -h264, -avc Force the program to treat the input as MPEG-4/AVC.\n"
" -h262 Force the program to treat the input as MPEG-2.\n"
" -avs Force the program to treat the input as AVS.\n"
);
}
int main(int argc, char **argv)
{
int use_stdin = FALSE;
int use_stdout = FALSE;
int use_tcpip = FALSE;
int port = 88; // Useful default port number
char *input_name = NULL;
char *output_name = NULL;
int had_input_name = FALSE;
int had_output_name = FALSE;
TS_writer_p output = NULL;
ES_p es;
int verbose = FALSE;
int quiet = FALSE;
int max = 0;
uint32_t video_pid = 0x68;
uint32_t pmt_pid = 0x66;
int err = 0;
int err2;
int ii = 1;
int video_type = VIDEO_H262; // hopefully a sensible default
int force_stream_type = FALSE;
byte stream_type = 0; // silly value to keep compiler quiet
if (argc < 2)
{
print_usage();
return 0;
}
while (ii < argc)
{
if (argv[ii][0] == '-')
{
if (!strcmp("--help",argv[ii]) || !strcmp("-help",argv[ii]) ||
!strcmp("-h",argv[ii]))
{
print_usage();
return 0;
}
else if (!strcmp("-avc",argv[ii]) || !strcmp("-h264",argv[ii]))
{
force_stream_type = TRUE;
video_type = VIDEO_H264;
}
else if (!strcmp("-h262",argv[ii]))
{
force_stream_type = TRUE;
video_type = VIDEO_H262;
}
else if (!strcmp("-avs",argv[ii]))
{
force_stream_type = TRUE;
video_type = VIDEO_AVS;
}
else if (!strcmp("-stdin",argv[ii]))
{
had_input_name = TRUE; // more or less
use_stdin = TRUE;
}
else if (!strcmp("-stdout",argv[ii]))
{
had_output_name = TRUE; // more or less
use_stdout = TRUE;
redirect_output_stderr();
}
else if (!strcmp("-err",argv[ii]))
{
CHECKARG("es2ts",ii);
if (!strcmp(argv[ii+1],"stderr"))
redirect_output_stderr();
else if (!strcmp(argv[ii+1],"stdout"))
redirect_output_stdout();
else
{
fprint_err("### es2ts: "
"Unrecognised option '%s' to -err (not 'stdout' or"
" 'stderr')\n",argv[ii+1]);
return 1;
}
ii++;
}
else if (!strcmp("-host",argv[ii]))
{
CHECKARG("es2ts",ii);
err = host_value("es2ts",argv[ii],argv[ii+1],&output_name,&port);
if (err) return 1;
had_output_name = TRUE; // more or less
use_tcpip = TRUE;
ii++;
}
else if (!strcmp("-verbose",argv[ii]) || !strcmp("-v",argv[ii]))
{
verbose = TRUE;
quiet = FALSE;
}
else if (!strcmp("-quiet",argv[ii]) || !strcmp("-q",argv[ii]))
{
verbose = FALSE;
quiet = TRUE;
}
else if (!strcmp("-max",argv[ii]) || !strcmp("-m",argv[ii]))
{
CHECKARG("es2ts",ii);
err = int_value("es2ts",argv[ii],argv[ii+1],TRUE,10,&max);
if (err) return 1;
ii++;
}
else if (!strcmp("-pid",argv[ii]))
{
CHECKARG("es2ts",ii);
err = unsigned_value("es2ts",argv[ii],argv[ii+1],0,&video_pid);
if (err) return 1;
ii++;
}
else if (!strcmp("-pmt",argv[ii]))
{
CHECKARG("es2ts",ii);
err = unsigned_value("es2ts",argv[ii],argv[ii+1],0,&pmt_pid);
if (err) return 1;
ii++;
}
else
{
fprint_err("### es2ts: "
"Unrecognised command line switch '%s'\n",argv[ii]);
return 1;
}
}
else
{
if (had_input_name && had_output_name)
{
fprint_err("### es2ts: Unexpected '%s'\n",argv[ii]);
return 1;
}
else if (had_input_name)
{
output_name = argv[ii];
had_output_name = TRUE;
}
else
{
input_name = argv[ii];
had_input_name = TRUE;
}
}
ii++;
}
if (!had_input_name)
{
print_err("### es2ts: No input file specified\n");
return 1;
}
if (!had_output_name)
{
print_err("### es2ts: No output file specified\n");
return 1;
}
// Try to stop extraneous data ending up in our output stream
if (use_stdout)
{
verbose = FALSE;
quiet = TRUE;
}
if (use_stdin)
err = open_elementary_stream(NULL,&es);
else
err = open_elementary_stream(input_name,&es);
if (err)
{
print_err("### es2ts: "
"Problem starting elementary stream - abandoning reading\n");
return 1;
}
if (!quiet)
fprint_msg("Reading from %s\n",(use_stdin?"<stdin>":input_name));
// Decide if the input stream is H.262 or H.264
if (force_stream_type || use_stdin)
{
if (!quiet) print_msg("Reading input as ");
}
else
{
int video_type;
err = decide_ES_file_video_type(es->input,FALSE,verbose,&video_type);
if (err)
{
print_err("### es2ts: Error deciding on stream type\n");
close_elementary_stream(&es);
return 1;
}
if (!quiet) print_msg("Input appears to be ");
}
switch (video_type)
{
case VIDEO_H262:
stream_type = MPEG2_VIDEO_STREAM_TYPE;
if (!quiet) print_msg("MPEG-2 (H.262)\n");
break;
case VIDEO_H264:
stream_type = AVC_VIDEO_STREAM_TYPE;
if (!quiet) print_msg("MPEG-4/AVC (H.264)\n");
break;
case VIDEO_AVS:
stream_type = AVS_VIDEO_STREAM_TYPE;
if (!quiet) print_msg("AVS\n");
break;
case VIDEO_UNKNOWN:
if (!quiet) print_msg("Unknown\n");
print_err("### es2ts: Input video type is not recognised\n");
close_elementary_stream(&es);
return 1;
}
if (use_stdout)
err = tswrite_open(TS_W_STDOUT,NULL,NULL,0,quiet,&output);
else if (use_tcpip)
err = tswrite_open(TS_W_TCP,output_name,NULL,port,quiet,&output);
else
err = tswrite_open(TS_W_FILE,output_name,NULL,0,quiet,&output);
if (err)
{
close_elementary_stream(&es);
fprint_err("### es2ts: Unable to open %s\n",output_name);
return 1;
}
if (max && !quiet)
fprint_msg("Stopping after %d ES data units\n",max);
err = transfer_data(es,output,pmt_pid,video_pid,stream_type,
max,verbose,quiet);
if (err)
print_err("### es2ts: Error transferring data\n");
close_elementary_stream(&es); // Closes the input file for us
err2 = tswrite_close(output,quiet);
if (err2)
{
fprint_err("### es2ts: Error closing output %s: %s\n",output_name,
strerror(errno));
return 1;
}
if (err)
return 1;
else
return 0;
}
// Local Variables:
// tab-width: 8
// indent-tabs-mode: nil
// c-basic-offset: 2
// End:
// vim: set tabstop=8 shiftwidth=2 expandtab:
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik