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

883 wiersze
27 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.

/*
* Support for "filtering" ES, outputting to either ES or TS.
*
* This provides the ability to "fast forward" through ES data.
*
* ***** 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 <errno.h>
#include <fcntl.h>
#include <string.h>
#ifdef _WIN32
#include <io.h>
#else // _WIN32
#include <unistd.h>
#endif // _WIN32
#include "compat.h"
#include "es_fns.h"
#include "ts_fns.h"
#include "accessunit_fns.h"
#include "h262_fns.h"
#include "misc_fns.h"
#include "printing_fns.h"
#include "filter_fns.h"
#define DEBUG 0
// ============================================================
// Managing H.262 filter contexts
// ============================================================
/*
* Build a new H.262 (MPEG-2 and also MPEG-1) filter context
*
* Returns 0 if all goes well, 1 if something goes wrong
*/
static int new_h262_filter_context(h262_filter_context_p *fcontext)
{
h262_filter_context_p new = malloc(SIZEOF_H262_FILTER_CONTEXT);
if (new == NULL)
{
print_err("### Unable to allocate H.262 filter context\n");
return 1;
}
new->h262 = NULL;
new->last_seq_hdr = NULL;
new->new_seq_hdr = FALSE;
reset_h262_filter_context(new);
*fcontext = new;
return 0;
}
/*
* Build a new filter context for "stripping" H.262 data
*
* - `fcontext` is the new filter context
* - `h262` is the H.262 stream to read from
* - `all_IP` is true if the software should keep all I and P pictures
*
* Returns 0 if all goes well, 1 if something goes wrong
*/
extern int build_h262_filter_context_strip(h262_filter_context_p *fcontext,
h262_context_p h262,
int all_IP)
{
int err = new_h262_filter_context(fcontext);
if (err) return 1;
(*fcontext)->h262 = h262;
(*fcontext)->filter = FALSE;
(*fcontext)->allref = all_IP;
return 0;
}
/*
* Build a new filter context for "filtering" H.262 data
*
* - `fcontext` is the new filter context
* - `h262` is the H.262 stream to read from
* - `freq` is the desired speed-up, or the frequency at which frames
* should (ideally) be kept
*
* Returns 0 if all goes well, 1 if something goes wrong
*/
extern int build_h262_filter_context(h262_filter_context_p *fcontext,
h262_context_p h262,
int freq)
{
int err = new_h262_filter_context(fcontext);
if (err) return 1;
(*fcontext)->h262 = h262;
(*fcontext)->filter = TRUE;
(*fcontext)->freq = freq;
return 0;
}
/*
* Reset an H.262 filter context, ready to start filtering anew.
*/
extern void reset_h262_filter_context(h262_filter_context_p fcontext)
{
fcontext->pending_EOF = FALSE;
fcontext->last_was_slice = FALSE;
fcontext->had_previous_picture = FALSE;
if (fcontext->last_seq_hdr != NULL)
free_h262_picture(&fcontext->last_seq_hdr);
fcontext->new_seq_hdr = FALSE;
fcontext->count = 0;
fcontext->frames_seen = 0;
fcontext->frames_written = 0;
}
/*
* Free a filter context
*
* NOTE that this does *not* free the H.262 datastructure to which the
* filter context refers.
*
* - `fcontext` is the filter context, which will be freed, and returned
* as NULL.
*/
extern void free_h262_filter_context(h262_filter_context_p *fcontext)
{
if ((*fcontext) == NULL)
return;
// It's a little wasteful to call this, but on the other hand it is
// guaranteed to free everything we want freeing
reset_h262_filter_context(*fcontext);
// Just lose our reference to the H.262 datastructure, don't free it
(*fcontext)->h262 = NULL;
free(*fcontext);
*fcontext = NULL;
return;
}
// ============================================================
// Managing H.264 filter contexts
// ============================================================
/*
* Build a new H.264 filter context
*
* Returns 0 if all goes well, 1 if something goes wrong
*/
static int new_h264_filter_context(h264_filter_context_p *fcontext)
{
h264_filter_context_p new = malloc(SIZEOF_H264_FILTER_CONTEXT);
if (new == NULL)
{
print_err("### Unable to allocate H.264 filter context\n");
return 1;
}
// Unset the important things - things we might otherwise try to free
// (or, for new->es, things that stop us doing anything until we're
// setup properly by the user)
new->access_unit_context = NULL;
reset_h264_filter_context(new);
*fcontext = new;
return 0;
}
/*
* Build a new filter context for "stripping" ES data
*
* - `fcontext` is the new filter context
* - `access` is the access unit context to read from
* - `allref` is true if the software should keep all reference pictures
* (H.264) or all I and P pictures (H.264)
*
* Returns 0 if all goes well, 1 if something goes wrong
*/
extern int build_h264_filter_context_strip(h264_filter_context_p *fcontext,
access_unit_context_p access,
int allref)
{
int err = new_h264_filter_context(fcontext);
if (err) return 1;
(*fcontext)->access_unit_context = access;
(*fcontext)->filter = FALSE;
(*fcontext)->allref = allref;
return 0;
}
/*
* Build a new filter context for "filtering" ES data
*
* - `fcontext` is the new filter context
* - `access` is the access unit context to read from
* - `freq` is the desired speed-up, or the frequency at which frames
* should (ideally) be kept
*
* Returns 0 if all goes well, 1 if something goes wrong
*/
extern int build_h264_filter_context(h264_filter_context_p *fcontext,
access_unit_context_p access,
int freq)
{
int err = new_h264_filter_context(fcontext);
if (err) return 1;
(*fcontext)->access_unit_context = access;
(*fcontext)->filter = TRUE;
(*fcontext)->freq = freq;
return 0;
}
/*
* Reset an H.264 filter context, ready to start filtering anew.
*/
extern void reset_h264_filter_context(h264_filter_context_p fcontext)
{
// `skipped_ref_pic` is TRUE if we've skipped any reference pictures
// since our last IDR (hmm - should it start off True or False?)
fcontext->skipped_ref_pic = FALSE;
// `last_accepted_was_not_IDR` is TRUE if the last frame kept (output)
// was not an IDR. We set it TRUE initially so that we will decide
// to output the first IDR we *do* find, regardless of the count.
fcontext->last_accepted_was_not_IDR = TRUE;
// And plainly we didn't have a previous access unit
fcontext->had_previous_access_unit = FALSE;
// Especially not an IDR
fcontext->not_had_IDR = TRUE;
fcontext->count = 0;
fcontext->frames_seen = 0;
fcontext->frames_written = 0;
}
/*
* Free an H.264 filter context
*
* NOTE that this does *not* free the access unit context to which the
* filter context refers.
*
* - `fcontext` is the filter context, which will be freed, and returned
* as NULL.
*/
extern void free_h264_filter_context(h264_filter_context_p *fcontext)
{
if ((*fcontext) == NULL)
return;
// It's a little wasteful to call this, but on the other hand it is
// guaranteed to free everything we want freeing
reset_h264_filter_context(*fcontext);
// Just lose our reference to the access unit context, don't free it
(*fcontext)->access_unit_context = NULL;
free(*fcontext);
*fcontext = NULL;
return;
}
// ============================================================
// Filtering H.262
// ============================================================
/*
* Retrieve the next I (and/or, if fcontext->allref, P) frame in this H.262 ES.
*
* Any sequence end "pictures" will be ignored.
*
* Note that the ES data being read should be video-only.
*
* - `fcontext` is the information that tells us what to filter and how
* - if `verbose` is true, then extra information will be output
* - if `quiet` is true, then only errors will be reported
*
* - `seq_hdr` is a sequence header, i.e., that used by the next frame to
* output. This will be NULL if the sequence header has not changed since
* the last call of this function.
*
* Note that the caller should *not* free this, and that it will not be
* maintained over calls of this function (i.e., it is a reference to a
* value within the `fcontext` which is altered by this function).
*
* - `frame` is the next frame to output.
*
* Note that it is the caller's responsibility to free this with
* `free_h262_picture()`.
*
* If an error or EOF is returned, this value is undefined.
*
* - `frames_seen` is the number of I and P frames (start code 0)
* found by this call of the function, including the item returned
* if appropriate.
*
* Returns 0 if it succeeds, EOF if end-of-file is read (or the last call
* returned a sequence end item), 1 if some error occurs.
*
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
* if the current command has changed.
*/
extern int get_next_stripped_h262_frame(h262_filter_context_p fcontext,
int verbose,
int quiet,
h262_picture_p *seq_hdr,
h262_picture_p *frame,
int *frames_seen)
{
int err;
// A picture is built up from several items - we start with none in hand
h262_picture_p this_picture = NULL;
*frames_seen = 0;
if (fcontext->filter)
{
print_err("### Calling get_next_stripped_h262_frame with a context"
" set for filtering\n");
return 1;
}
// Otherwise, look for something we want to keep
for (;;)
{
if (es_command_changed(fcontext->h262->es))
{
*frame = *seq_hdr = NULL;
return COMMAND_RETURN_CODE;
}
err = get_next_h262_frame(fcontext->h262,verbose,quiet,&this_picture);
if (err == EOF)
{
*frame = *seq_hdr = NULL;
return err;
}
else if (err)
{
print_err("### Error filtering H.262 frames\n");
return 1;
}
// Now to stripping
if (this_picture->is_picture)
{
(*frames_seen) ++;
if ((this_picture->picture_coding_type == 1) ||
(this_picture->picture_coding_type == 2 && fcontext->allref) )
{
*frame = this_picture;
if (fcontext->new_seq_hdr)
*seq_hdr = fcontext->last_seq_hdr;
else
*seq_hdr = NULL;
fcontext->new_seq_hdr = FALSE;
if (verbose) fprint_msg(">> %s picture \n",
(this_picture->picture_coding_type==1?"I":"P"));
return 0;
}
else
free_h262_picture(&this_picture);
}
else if (this_picture->is_sequence_header)
{
// We maybe want to remember this sequence header for the next picture
if (fcontext->last_seq_hdr == NULL)
{
fcontext->last_seq_hdr = this_picture;
fcontext->new_seq_hdr = TRUE;
if (verbose) print_msg(">> First sequence header\n");
}
else if (!same_h262_picture(this_picture,fcontext->last_seq_hdr))
{
if (verbose) print_msg(">> Different sequence header\n");
free_h262_picture(&fcontext->last_seq_hdr);
fcontext->last_seq_hdr = this_picture;
fcontext->new_seq_hdr = TRUE;
}
else
{
fcontext->new_seq_hdr = FALSE;
if (verbose) print_msg(">> Identical sequence header\n");
free_h262_picture(&this_picture);
}
}
}
}
/*
* Retrieve the next I frame, from the H.262 ES, aiming for an "apparent" kept
* frequency as stated.
*
* Any sequence end "pictures" will be ignored.
*
* Note that the ES data being read should be video-only.
*
* - `fcontext` is the information that tells us what to filter and how
* (including the desired frequency)
* - if `verbose` is true, then extra information will be output
* - if `quiet` is true, then only errors will be reported
*
* - `seq_hdr` is a sequence header, i.e., that used by the next picture to
* output. This will be NULL if `frame` is NULL.
*
* Note that the caller should *not* free this, and that it will not be
* maintained over calls of this function (i.e., it is a reference to a
* value within the `fcontext` which is altered by this function).
*
* - `frame` is the next frame to output. This will be NULL if the last frame
* should be output again, to provide the requested apparent frequency.
*
* Note that it is the caller's responsibility to free this with
* `free_h262_picture()`.
*
* If an error or EOF is returned, this value is undefined.
*
* - `frames_seen` is the number of I and P frames found by this call of
* the function, including the item returned if appropriate.
*
* Returns 0 if it succeeds, EOF if end-of-file is read, or we've just read a
* sequence end item, or the last call ended a picture on a sequence end
* item, 1 if some error occurs.
*
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
* if the current command has changed.
*/
extern int get_next_filtered_h262_frame(h262_filter_context_p fcontext,
int verbose,
int quiet,
h262_picture_p *seq_hdr,
h262_picture_p *frame,
int *frames_seen)
{
int err;
// A picture is built up from several items - we start with none in hand
h262_picture_p this_picture = NULL;
*frames_seen = 0;
if (!fcontext->filter)
{
print_err("### Calling get_next_filtered_h262_frame with a context"
" set for stripping\n");
return 1;
}
// Otherwise, look for something we want to keep
for (;;)
{
if (es_command_changed(fcontext->h262->es))
{
*frame = *seq_hdr = NULL;
return COMMAND_RETURN_CODE;
}
// If the picture is an I picture, we want it to contain an appropriate
// AFD - so ask for that
fcontext->h262->add_fake_afd = TRUE;
err = get_next_h262_frame(fcontext->h262,verbose,quiet,&this_picture);
if (err == EOF)
{
*frame = *seq_hdr = NULL;
fcontext->h262->add_fake_afd = FALSE;
return err;
}
else if (err)
{
print_err("### Error filtering H.262 frames\n");
fcontext->h262->add_fake_afd = FALSE;
return 1;
}
// Reinstate normal "only include actual AFDs"
fcontext->h262->add_fake_afd = FALSE;
// Now to filtering
if (this_picture->is_picture)
{
fcontext->count ++;
(*frames_seen) ++;
fcontext->frames_seen ++;
if (this_picture->picture_coding_type == 1 &&
fcontext->count < fcontext->freq)
{
// It is an I picture, but it is too soon
if (verbose)
{
fprint_msg("+++ %d/%d DROP: Too soon\n",fcontext->count,fcontext->freq);
}
}
else if (this_picture->picture_coding_type != 1)
{
// It is not an I picture
if (verbose)
{
fprint_msg("+++ %d/%d DROP: %s picture\n",fcontext->count,fcontext->freq,
H262_PICTURE_CODING_STR(this_picture->picture_coding_type));
}
// But do we want to pad with (i.e., repeat) the previous I picture?
if (fcontext->freq > 0)
{
int pictures_wanted = fcontext->frames_seen / fcontext->freq;
int repeat = pictures_wanted - fcontext->frames_written;
if (repeat > 0 && fcontext->had_previous_picture)
{
if (verbose) print_msg(">>> output last picture again\n");
free_h262_picture(&this_picture);
*seq_hdr = NULL;
*frame = NULL;
fcontext->frames_written ++;
return 0;
}
}
}
else
{
// It was an I picture, and not too soon
if (verbose)
{
fprint_msg("+++ %d/%d KEEP\n",fcontext->count,fcontext->freq);
}
fcontext->count = 0;
fcontext->had_previous_picture = TRUE;
*seq_hdr = fcontext->last_seq_hdr;
*frame = this_picture;
fcontext->frames_written ++;
return 0;
}
free_h262_picture(&this_picture);
}
else if (this_picture->is_sequence_header)
{
// We want to remember the sequence header for the next picture
if (fcontext->last_seq_hdr != NULL)
free_h262_picture(&fcontext->last_seq_hdr);
fcontext->last_seq_hdr = this_picture;
}
}
}
// ============================================================
// Filtering H.264
// ============================================================
/*
* Return the next IDR or I (and maybe any reference) frame from this H.264 ES.
*
* Note that the ES data being read should be video-only.
*
* - `fcontext` is the information that tells us what to filter and how
* - if `verbose` is true, then extra information will be output
* - if `quiet` is true, then only errors will be reported
* - `frame` is the next frame to output.
* Note that it is the caller's responsibility to free this with
* `free_access_unit()`.
* If an error or EOF is returned, this value is undefined.
* - `frames_seen` is the number of frames found by this call
* of the function, including the frame returned.
*
* Returns 0 if it succeeds, EOF if end-of-file is read (or an an end of
* stream NAL unit has been passed), 1 if some error occurs.
*
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
* if the current command has changed.
*/
extern int get_next_stripped_h264_frame(h264_filter_context_p fcontext,
int verbose,
int quiet,
access_unit_p *frame,
int *frames_seen)
{
int err = 0;
int keep = FALSE; // Should we keep the current access unit?
access_unit_p this_access_unit = NULL;
*frames_seen = 0;
for (;;)
{
if (es_command_changed(fcontext->access_unit_context->nac->es))
return COMMAND_RETURN_CODE;
if (verbose)
print_msg("\n");
err = get_next_h264_frame(fcontext->access_unit_context,quiet,verbose,
&this_access_unit);
if (err == EOF)
return err;
else if (err)
return 1;
(*frames_seen) ++;
if (this_access_unit->primary_start == NULL)
{
// We don't have a primary picture - no VCL NAL
// There seems little point in keeping the access unit
keep = FALSE;
if (verbose)
print_msg("++ DROP: no primary picture\n");
}
else if (this_access_unit->primary_start->nal_ref_idc == 0)
{
// This is not a reference frame, so it's of no interest
keep = FALSE;
if (verbose)
print_msg("++ DROP: not reference\n");
}
else if (fcontext->allref)
{
// We want to keep all reference frames
if (this_access_unit->primary_start->nal_unit_type == NAL_IDR ||
this_access_unit->primary_start->nal_unit_type == NAL_NON_IDR)
{
keep = TRUE;
if (verbose)
print_msg("++ KEEP: reference picture\n");
}
else
{
keep = FALSE;
if (verbose)
print_msg("++ DROP: sequence or parameter set, etc.\n");
}
}
else
{
// We only want to keep IDR and I frames
if (this_access_unit->primary_start->nal_unit_type == NAL_IDR)
{
keep = TRUE;
if (verbose)
print_msg("++ KEEP: IDR picture\n");
}
else if (this_access_unit->primary_start->nal_unit_type == NAL_NON_IDR &&
all_slices_I(this_access_unit))
{
keep = TRUE;
if (verbose)
print_msg("++ KEEP: all slices I\n");
}
else
{
keep = FALSE;
if (verbose)
print_msg("++ DROP: not IDR or all slices I\n");
}
}
if (keep)
{
*frame = this_access_unit;
return 0;
}
// We've no further use for this access unit
free_access_unit(&this_access_unit);
}
}
/*
* Retrieve the next frame from the H.264 (MPEG-4/AVC) ES, aiming
* for an "apparent" kept frequency as stated.
*
* Note that the ES data being read should be video-only.
*
* - `fcontext` is the information that tells us what to filter and how
* (including the desired frequency)
* - if `verbose` is true, then extra information will be output
* - if `quiet` is true, then only errors will be reported
*
* - `frame` is the next frame to output.
*
* If the function succeeds and `frame` is NULL, it means that the
* last frame should be output again.
*
* Note that it is the caller's responsibility to free this frame with
* `free_access_unit()`.
*
* If an error or EOF is returned, this value is undefined.
*
* - `frames_seen` is the number of frames found by this call of the function,
* including the frame returned.
*
* Returns 0 if all went well, 1 if something went wrong.
*
* If command input is enabled, then it can also return COMMAND_RETURN_CODE
* if the current command has changed.
*/
extern int get_next_filtered_h264_frame(h264_filter_context_p fcontext,
int verbose,
int quiet,
access_unit_p *frame,
int *frames_seen)
{
int err = 0;
int keep = FALSE; // Should we keep the current access unit?
access_unit_p this_access_unit = NULL;
*frames_seen = 0;
for (;;)
{
if (es_command_changed(fcontext->access_unit_context->nac->es))
return COMMAND_RETURN_CODE;
if (verbose)
print_msg("\n");
err = get_next_h264_frame(fcontext->access_unit_context,quiet,verbose,
&this_access_unit);
if (err == EOF)
return err;
else if (err)
return 1;
fcontext->count ++;
(*frames_seen) ++;
fcontext->frames_seen ++;
if (this_access_unit->primary_start == NULL)
{
// We don't have a primary picture - no VCL NAL
// There seems little point in keeping the access unit
keep = FALSE;
if (verbose)
fprint_msg("++ %d/%d DROP: no primary picture\n",
fcontext->count,fcontext->freq);
}
else if (this_access_unit->primary_start->nal_ref_idc == 0)
{
// This is not a reference frame, so it's of no interest
keep = FALSE;
if (verbose)
fprint_msg("++ %d/%d DROP: not a reference frame\n",
fcontext->count,fcontext->freq);
}
else if (this_access_unit->primary_start->nal_unit_type == NAL_IDR &&
fcontext->last_accepted_was_not_IDR)
{
// This frame is an IDR, and the last frame kept was not, so
// we'll output it regardless - we don't expect to get enough
// IDR pictures that this will be a problem, and they're
// valuable because they're the "limit" for other frames that
// refer backwards
// (should we reset the count to zero? - seems sensible)
keep = TRUE;
fcontext->not_had_IDR = FALSE;
fcontext->skipped_ref_pic = FALSE;
fcontext->last_accepted_was_not_IDR = FALSE;
if (verbose)
fprint_msg("++ %d/%d KEEP: IDR and last was not\n",
fcontext->count,fcontext->freq);
}
else if (this_access_unit->primary_start->nal_unit_type == NAL_IDR &&
fcontext->not_had_IDR)
{
// We haven't had an IDR yet in this filter run, so we had better
// output this one as a "good start"
keep = TRUE;
fcontext->skipped_ref_pic = FALSE;
fcontext->last_accepted_was_not_IDR = FALSE;
if (verbose)
fprint_msg("++ %d/%d KEEP: IDR and first IDR of filter run\n",
fcontext->count,fcontext->freq);
}
else if (fcontext->count < fcontext->freq)
{
// It's too soon, so ignore it - but notice that we *have*
// ignored a reference picture
keep = FALSE;
fcontext->skipped_ref_pic = TRUE;
if (verbose)
fprint_msg("++ %d/%d DROP: Too soon (skipping ref frame)\n",
fcontext->count,fcontext->freq);
}
else if (this_access_unit->primary_start->nal_unit_type == NAL_IDR)
{
// It's an IDR, so output it
keep = TRUE;
fcontext->skipped_ref_pic = FALSE;
fcontext->last_accepted_was_not_IDR = FALSE;
if (verbose)
fprint_msg("++ %d/%d KEEP: IDR\n",fcontext->count,fcontext->freq);
}
else if (all_slices_I(this_access_unit))
{
// It is an I picture (either it has all of its slices
// type "I", or it has a single slice which is of type "I")
keep = TRUE;
fcontext->last_accepted_was_not_IDR = TRUE;
if (verbose)
fprint_msg("++ %d/%d KEEP: I frame\n",fcontext->count,fcontext->freq);
}
else if (!fcontext->skipped_ref_pic && all_slices_I_or_P(this_access_unit))
{
// It is a P or I&P picture, but we know that we have output all
// the reference pictures since the last IDR, so it is
// safe to output it
keep = TRUE;
fcontext->last_accepted_was_not_IDR = TRUE;
if (verbose)
fprint_msg("++ %d/%d KEEP: P frame. no skipped ref frames\n",
fcontext->count,fcontext->freq);
}
else
{
keep = FALSE;
fcontext->skipped_ref_pic = TRUE;
if (verbose)
fprint_msg("++ %d/%d DROP: ref frame skipped earlier\n",
fcontext->count,fcontext->freq);
}
if (keep)
{
*frame = this_access_unit;
fcontext->had_previous_access_unit = TRUE;
fcontext->frames_written ++;
fcontext->count = 0;
return 0;
}
else
{
if (fcontext->freq > 0)
{
int access_units_wanted = fcontext->frames_seen / fcontext->freq;
int repeat = access_units_wanted - fcontext->frames_written;
if (repeat > 0 && fcontext->had_previous_access_unit)
{
if (verbose) print_msg(">>> output last access unit again\n");
free_access_unit(&this_access_unit);
*frame = NULL;
fcontext->frames_written ++;
return 0;
}
}
// We've no further use for this access unit
free_access_unit(&this_access_unit);
}
}
}
// 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