kopia lustrzana https://github.com/F5OEO/tstools
197 wiersze
6.6 KiB
C
197 wiersze
6.6 KiB
C
/*
|
||
* Prototypes for reading AVS elementary streams.
|
||
*
|
||
* ***** 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 *****
|
||
*/
|
||
|
||
#ifndef _avs_fns
|
||
#define _avs_fns
|
||
|
||
#include "avs_defns.h"
|
||
|
||
/*
|
||
* Return a string representing the start code
|
||
*/
|
||
extern const char *avs_start_code_str(byte start_code);
|
||
/*
|
||
* Determine the picture coding type of an AVS ES unit
|
||
*
|
||
* P/B frames are distinguished by their picture coding types. For I frames,
|
||
* we make one up...
|
||
*
|
||
* Returns an appropriate value (0 if none suitable)
|
||
*/
|
||
extern int avs_picture_coding_type(ES_unit_p unit);
|
||
/*
|
||
* Build a new AVS frame reading context.
|
||
*
|
||
* This acts as a "jacket" around the ES context, and is used when reading
|
||
* AVS frames with get_next_avs_frame(). It "remembers" the last
|
||
* item read, which is the first item that was not part of the frame.
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int build_avs_context(ES_p es,
|
||
avs_context_p *context);
|
||
/*
|
||
* Free an AVS frame reading context.
|
||
*
|
||
* Clears the datastructure, frees it, and returns `context` as NULL.
|
||
*
|
||
* Does not free any `reverse_data` datastructure.
|
||
*
|
||
* Does nothing if `context` is already NULL.
|
||
*/
|
||
extern void free_avs_context(avs_context_p *context);
|
||
/*
|
||
* Rewind a file being read as AVS frames
|
||
*
|
||
* This is a wrapper for `seek_ES` that also knows to unset things appropriate
|
||
* to the AVS frame reading context.
|
||
*
|
||
* If a reverse context is attached to this context, it also will
|
||
* be "rewound" appropriately.
|
||
*
|
||
* Returns 0 if all goes well, 1 if something goes wrong.
|
||
*/
|
||
extern int rewind_avs_context(avs_context_p context);
|
||
/*
|
||
* Free an AVS "frame".
|
||
*
|
||
* Clears the datastructure, frees it, and returns `frame` as NULL.
|
||
*
|
||
* Does nothing if `frame` is already NULL.
|
||
*/
|
||
extern void free_avs_frame(avs_frame_p *frame);
|
||
/*
|
||
* Retrieve the the next AVS "frame".
|
||
*
|
||
* The AVS "frame" returned can be one of:
|
||
*
|
||
* 1. A frame, including its slices.
|
||
* 2. A sequence header, including its sequence extension, if any.
|
||
* 3. A sequence end.
|
||
*
|
||
* Specifically, the next AVS "frame" is retrieved from the input stream.
|
||
*
|
||
* If that "frame" represents a sequence header or a frame, it is returned.
|
||
*
|
||
* Note that if the context is associated with a reverse context,
|
||
* then appropriate frames/sequence headers will automatically be
|
||
* remembered therein.
|
||
*
|
||
* - `context` is the AVS frame reading context.
|
||
* - if `verbose` is true, then extra information will be output
|
||
* - if `quiet` is true, then only errors will be reported
|
||
* - `frame` is the AVS "frame", containing a frame, a sequence header or a
|
||
* sequence end
|
||
*
|
||
* Returns 0 if it succeeds, EOF if we reach the end of file, or 1 if some
|
||
* error occurs.
|
||
*/
|
||
extern int get_next_avs_frame(avs_context_p context,
|
||
int verbose,
|
||
int quiet,
|
||
avs_frame_p *frame);
|
||
/*
|
||
* Write out an AVS frame as TS
|
||
*
|
||
* - `tswriter` is TS the output stream
|
||
* - `frame` is the frame to write out
|
||
* - `pid` is the PID to use for the TS packets
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int write_avs_frame_as_TS(TS_writer_p tswriter,
|
||
avs_frame_p frame,
|
||
uint32_t pid);
|
||
/*
|
||
* Write out an AVS frame as TS, with PTS timing in the first PES packet
|
||
* (and PCR timing in the first TS of the frame).
|
||
*
|
||
* - `frame` is the frame to write out
|
||
* - `tswriter` is the TS context to write with
|
||
* - `video_pid` is the PID to use to write the data
|
||
* - `got_pts` is TRUE if we have a PTS value, in which case
|
||
* - `pts` is said PTS value
|
||
* - `got_dts` is TRUE if we also have DTS, in which case
|
||
* - `dts` is said DTS value.
|
||
*
|
||
* If we are given a DTS (which must, by definition, always go up) we will also
|
||
* use it as the value for PCR.
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int write_avs_frame_as_TS_with_pts_dts(avs_frame_p frame,
|
||
TS_writer_p tswriter,
|
||
uint32_t video_pid,
|
||
int got_pts,
|
||
uint64_t pts,
|
||
int got_dts,
|
||
uint64_t dts);
|
||
/*
|
||
* Write out an AVS frame as TS, with PCR timing in the first TS of the
|
||
* frame.
|
||
*
|
||
* - `frame` is the frame to write out
|
||
* - `tswriter` is the TS context to write with
|
||
* - `video_pid` is the PID to use to write the data
|
||
* - `pcr_base` and `pcr_extn` encode the PCR value.
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int write_avs_frame_as_TS_with_PCR(avs_frame_p frame,
|
||
TS_writer_p tswriter,
|
||
uint32_t video_pid,
|
||
uint64_t pcr_base,
|
||
uint32_t pcr_extn);
|
||
/*
|
||
* Write out a frame (as stored in an ES unit list) as ES
|
||
*
|
||
* - `output` is the ES output file
|
||
* - `frame` is the frame to write out
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int write_avs_frame_as_ES(FILE *output,
|
||
avs_frame_p frame);
|
||
/*
|
||
* Report on an AVS frame's contents.
|
||
*
|
||
* - `frame` is the frame to report on
|
||
* - if `report_data`, then the component ES units will be printed out as well
|
||
*/
|
||
extern void report_avs_frame(avs_frame_p frame,
|
||
int report_data);
|
||
|
||
#endif // _avs_fns
|
||
|
||
// Local Variables:
|
||
// tab-width: 8
|
||
// indent-tabs-mode: nil
|
||
// c-basic-offset: 2
|
||
// End:
|
||
// vim: set tabstop=8 shiftwidth=2 expandtab:
|