kopia lustrzana https://github.com/F5OEO/tstools
341 wiersze
15 KiB
C
341 wiersze
15 KiB
C
/*
|
||
* Support for reversing
|
||
*
|
||
* ***** 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 _reverse_fns
|
||
#define _reverse_fns
|
||
|
||
#include "accessunit_defns.h"
|
||
#include "reverse_defns.h"
|
||
#include "h262_defns.h"
|
||
|
||
/*
|
||
* Build the internal arrays to remember video sequence bounds in,
|
||
* for reversing.
|
||
*
|
||
* Builds a new `reverse_data` datastructure. If `is_h264` is FALSE (i.e., the
|
||
* data to be reversed is not MPEG-1 or MPEG-2), then this datastructure may
|
||
* be smaller.
|
||
*
|
||
* To collect reversing data, attach this datastructure to an H.262 or access
|
||
* unit context (with add_h262/access_unit_reverse_context), and then use
|
||
* get_next_h262_frame() or get_next_h264_frame() to read through the data
|
||
* stream - appropriate pictures/access units will be remembered
|
||
* automatically.
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int build_reverse_data(reverse_data_p *reverse_data,
|
||
int is_h264);
|
||
/*
|
||
* Set the video PID and stream id for TS output.
|
||
*
|
||
* This need only be called if reverse data *is* being output as TS,
|
||
* and if the standard default values (DEFAULT_VIDEO_PID and
|
||
* DEFAULT_VIDEO_STREAM_ID) are not correct.
|
||
*/
|
||
extern void set_reverse_pid(reverse_data_p reverse_data,
|
||
u_int32 pid,
|
||
byte stream_id);
|
||
/*
|
||
* Add a reversing context to an H.262 context (and vice versa).
|
||
*
|
||
* Does not check if there is one present already.
|
||
*
|
||
* Returns 0 if all is well, 1 if something goes wrong.
|
||
*/
|
||
extern int add_h262_reverse_context(h262_context_p h262,
|
||
reverse_data_p reverse_data);
|
||
/*
|
||
* Add a reversing context to an access unit context (and vice versa).
|
||
*
|
||
* Does not check if there is one present already.
|
||
*
|
||
* Returns 0 if all is well, 1 if something goes wrong.
|
||
*/
|
||
extern int add_access_unit_reverse_context(access_unit_context_p context,
|
||
reverse_data_p reverse_data);
|
||
|
||
/*
|
||
* Free the datastructure we used to remember reversing data
|
||
*
|
||
* Sets `reverse_data` to NULL.
|
||
*/
|
||
extern void free_reverse_data(reverse_data_p *reverse_data);
|
||
/*
|
||
* Remember video sequence bounds for H.262 data
|
||
*
|
||
* - `reverse_data` is the datastructure we want to add our entry to
|
||
* - `index` indicates which picture (counted from the start of the file)
|
||
* this one is (i.e., we're assuming that not all pictures will be stored).
|
||
* If the entry is an H.262 sequence header, then this is ignored.
|
||
* - `start_posn` is the location of the start of the entry in the file,
|
||
* The entry will be ignored if `start_posn` comes before the last
|
||
* existing entry in the arrays.
|
||
* - `length` is the number of bytes in the entry
|
||
* - in H.262 data, `seq_offset` should be 0 for a sequence header, and is
|
||
* otherwise the offset backwards to the previous nearest sequence header
|
||
* (i.e., 1 if the sequence header is the previous entry).
|
||
* - `afd` is the effective AFD byte for this picture
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int remember_reverse_h262_data(reverse_data_p reverse_data,
|
||
u_int32 index,
|
||
ES_offset start_posn,
|
||
u_int32 length,
|
||
byte seq_offset,
|
||
byte afd);
|
||
/*
|
||
* Remember video sequence bounds for H.264 data
|
||
*
|
||
* - `reverse_data` is the datastructure we want to add our entry to
|
||
* - `index` indicates which picture (counted from the start of the file)
|
||
* this one is (i.e., we're assuming that not all pictures will be stored).
|
||
* If the entry is an H.262 sequence header, then this is ignored.
|
||
* - `start_posn` is the location of the start of the entry in the file,
|
||
* The entry will be ignored if `start_posn` comes before the last
|
||
* existing entry in the arrays.
|
||
* - `length` is the number of bytes in the entry
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int remember_reverse_h264_data(reverse_data_p reverse_data,
|
||
u_int32 index,
|
||
ES_offset start_posn,
|
||
u_int32 length);
|
||
/*
|
||
* Retrieve video sequence bounds for entry `which`
|
||
*
|
||
* - `reverse_data` is the datastructure we want to get our entry from
|
||
* - `which` indicates which entry we'd like to retrieve. The first
|
||
* entry in the `reverse_data` is number 0.
|
||
* - `index` indicates which picture (counted from the start of the file)
|
||
* this one is (i.e., we're assuming that not all pictures will be stored).
|
||
* `index` may be passed as NULL if the value is of no interest - i.e.,
|
||
* typically when the entry is for an H.262 sequence header.
|
||
* - `start_posn` is the location of the start of the entry in the file,
|
||
* - `length` is the number of bytes in the entry
|
||
* - for H.262 data, if the entry is a picture, then `seq_offset` will
|
||
* be the offset backwards to the previous nearest sequence header
|
||
* (i.e., 1 if the sequence header is the previous entry), and if it is
|
||
* a sequence header, `seq_offset` will be 0. For H.264 data, the value
|
||
* will always be 0. `seq_offset` may be passed as NULL if the value is
|
||
* of no interest.
|
||
* - for H.262 data, if the entry is a picture, then `afd` will be its
|
||
* (effective) AFD byte. Otherwise it will be 0. `afd` may be passed as NULL
|
||
* if the value if of no interest.
|
||
*
|
||
* To clarify, all of the following are legitimate calls::
|
||
*
|
||
* err = get_reverse_data(reverse_data,10,&index,&start,&length,&offset,&afd);
|
||
* err = get_reverse_data(reverse_data,10,&index,&start,&length,NULL,NULL);
|
||
* err = get_reverse_data(reverse_data,10,NULL,&start,&length,NULL,NULL);
|
||
*
|
||
* Returns 0 if it succeeds, 1 if some error occurs.
|
||
*/
|
||
extern int get_reverse_data(reverse_data_p reverse_data,
|
||
int which,
|
||
u_int32 *index,
|
||
ES_offset *start_posn,
|
||
u_int32 *length,
|
||
byte *seq_offset,
|
||
byte *afd);
|
||
|
||
// ============================================================
|
||
// Collecting pictures
|
||
// ============================================================
|
||
/*
|
||
* Locate and remember sequence headers and I pictures, for later reversal.
|
||
*
|
||
* - `h262` is the H.262 stream reading context
|
||
* - if `max` is non-zero, then collecting will stop after `max` pictures
|
||
* - if `verbose` is true, then extra information will be output
|
||
* - if `quiet` is true, then only errors will be reported
|
||
*
|
||
* Returns 0 if all went well, EOF if the end of file is reached,
|
||
* and 1 if an error occurred.
|
||
*
|
||
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
|
||
* if the current command has changed.
|
||
*/
|
||
extern int collect_reverse_h262(h262_context_p h262,
|
||
int max,
|
||
int verbose,
|
||
int quiet);
|
||
/*
|
||
* Find IDR and I slices, and remember their access units for later output
|
||
* in reverse order.
|
||
*
|
||
* - `acontext` is the access unit reading context
|
||
* - if `max` is non-zero, then collecting will stop after `max` access units
|
||
* - if `verbose` is true, then extra information will be output
|
||
* - if `quiet` is true, then only errors will be reported
|
||
*
|
||
* Returns 0 if all went well, EOF if the end of file is reached,
|
||
* and 1 if an error occurred.
|
||
*
|
||
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
|
||
* if the current command has changed.
|
||
*/
|
||
extern int collect_reverse_access_units(access_unit_context_p acontext,
|
||
int max,
|
||
int verbose,
|
||
int quiet);
|
||
/*
|
||
* Output the last picture (or an earlier one) from the reverse arrays.
|
||
* This version writes the data out as Transport Stream.
|
||
*
|
||
* This is expected to be used after the whole of the data stream has been
|
||
* played, so that the last picture in the reverse arrays is the last I or
|
||
* IDR picture in the data stream.
|
||
*
|
||
* - `es` is the input elementary stream
|
||
* - `tswriter` is the transport stream writer
|
||
* - if `verbose` is true, then extra information will be output
|
||
* - if `quiet` is true, then only errors will be reported
|
||
* - `offset` is the offset from the end of the array of the picture
|
||
* to output - so 0 means the last picture, 1 the picture before that,
|
||
* and so on. Sequence headers do not count for this purpose.
|
||
* - `reverse_data` is the reverse data context.
|
||
*
|
||
* Returns 0 if all went well, 1 if an error occurred.
|
||
*
|
||
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
|
||
* if the current command has changed.
|
||
*/
|
||
extern int output_from_reverse_data_as_TS(ES_p es,
|
||
TS_writer_p tswriter,
|
||
int verbose,
|
||
int quiet,
|
||
u_int32 offset,
|
||
reverse_data_p reverse_data);
|
||
/*
|
||
* Output the last picture (or an earlier one) from the reverse arrays.
|
||
* This version writes the data out as Elementary Stream.
|
||
*
|
||
* This is expected to be used after the whole of the data stream has been
|
||
* played, so that the last picture in the reverse arrays is the last I or
|
||
* IDR picture in the data stream.
|
||
*
|
||
* - `es` is the input elementary stream
|
||
* - `output` is the stream to write to
|
||
* - if `verbose` is true, then extra information will be output
|
||
* - if `quiet` is true, then only errors will be reported
|
||
* - `offset` is the offset from the end of the array of the picture
|
||
* to output - so 0 means the last picture, 1 the picture before that,
|
||
* and so on. Sequence headers do not count for this purpose.
|
||
* - `reverse_data` is the reverse data context.
|
||
*
|
||
* Returns 0 if all went well, 1 if an error occurred.
|
||
*
|
||
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
|
||
* if the current command has changed.
|
||
*/
|
||
extern int output_from_reverse_data_as_ES(ES_p es,
|
||
FILE *output,
|
||
int verbose,
|
||
int quiet,
|
||
u_int32 offset,
|
||
reverse_data_p reverse_data);
|
||
/*
|
||
* Output the H.262 pictures or H.264 access units we remembered earlier - but
|
||
* in reverse order. This version writes the data out as Transport Stream.
|
||
*
|
||
* - `es` is the input elementary stream
|
||
* - `tswriter` is the transport stream writer
|
||
* - if `frequency` is non-zero, then attempt to produce the effect of
|
||
* keeping every <frequency>th picture (similar to reversing at a
|
||
* multiplication factor of `frequency`) If 0, just output all the
|
||
* pictures that were remembered.
|
||
* - if `verbose` is true, then extra information will be output
|
||
* - if `quiet` is true, then only errors will be reported
|
||
* - `start_with` is the index at which to start outputting from the
|
||
* reverse data arrays. The value -1 may be used to indicate the most
|
||
* recent picture in the arrays. If `start_with` is less than -1 then this
|
||
* function will do nothing. If `start_with` is off the end of the
|
||
* arrays, then reversing will start from the end of the arrays.
|
||
* - if `max` is non-zero, then output will stop after at least `max`
|
||
* pictures have been reversed past.
|
||
* - `reverse_data` contains the list of pictures/access units to reverse.
|
||
*
|
||
* Returns 0 if all went well, 1 if an error occurred.
|
||
*
|
||
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
|
||
* if the current command has changed.
|
||
*/
|
||
extern int output_in_reverse_as_TS(ES_p es,
|
||
TS_writer_p tswriter,
|
||
int frequency,
|
||
int verbose,
|
||
int quiet,
|
||
int32 start_with,
|
||
int max,
|
||
reverse_data_p reverse_data);
|
||
/*
|
||
* Output the H.262 pictures or H.264 access units we remembered earlier - but
|
||
* in reverse order. This version writes the data out as Elementary Stream.
|
||
*
|
||
* - `es` is the input elementary stream
|
||
* - `output` is the stream to write to
|
||
* - if `frequency` is non-zero, then attempt to produce the effect of
|
||
* keeping every <frequency>th picture (similar to reversing at a
|
||
* multiplication factor of `frequency`) If 0, just output all the
|
||
* pictures that were remembered.
|
||
* - if `verbose` is true, then extra information will be output
|
||
* - if `quiet` is true, then only errors will be reported
|
||
* - `start_with` is the index at which to start outputting from the
|
||
* reverse data arrays. The value -1 may be used to indicate the most
|
||
* recent in the arrays. If `start_with` is less than -1 then this
|
||
* function will do nothing. If `start_with` is off the end of the
|
||
* arrays, then reversing will start from the end of the arrays.
|
||
* - if `max` is non-zero, then output will stop after at least `max`
|
||
* pictures have been reversed past.
|
||
* - `reverse_data` contains the list of pictures/access units to reverse.
|
||
*
|
||
* Returns 0 if all went well, 1 if an error occurred.
|
||
*
|
||
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
|
||
* if the current command has changed.
|
||
*/
|
||
extern int output_in_reverse_as_ES(ES_p es,
|
||
FILE *output,
|
||
int frequency,
|
||
int verbose,
|
||
int quiet,
|
||
int32 start_with,
|
||
int max,
|
||
reverse_data_p reverse_data);
|
||
|
||
#endif // _reverse_fns
|
||
|
||
// Local Variables:
|
||
// tab-width: 8
|
||
// indent-tabs-mode: nil
|
||
// c-basic-offset: 2
|
||
// End:
|
||
// vim: set tabstop=8 shiftwidth=2 expandtab:
|