static void reset(struct ao *ao)
{
struct priv *priv = ao->priv;
SDL_LockMutex(priv->buffer_mutex);
av_fifo_reset(priv->buffer);
SDL_UnlockMutex(priv->buffer_mutex);
}
void av_audio_fifo_reset(AVAudioFifo *af)
{
int i;
for (i = 0; i < af->nb_buffers; i++)
av_fifo_reset(af->buf[i]);
af->nb_samples = 0;
}
void FFmpegDecoder::Rewind()
{
if (av->started)
{
av_seek_frame(av->ctx, -1, 0, AVSEEK_FLAG_BACKWARD);
av_fifo_reset(av->fifo);
av->started = false;
}
}
// stop playing and empty buffers (for seeking/pause)
static void reset(void){
//printf("SDL: reset called!\n");
SDL_PauseAudio(1);
/* Reset ring-buffer state */
av_fifo_reset(buffer);
SDL_PauseAudio(0);
}
/*
This function resets decoder and corresponded buffers before seek operation
*/
void ff_qsv_decode_reset(AVCodecContext *avctx, QSVContext *q)
{
QSVFrame *cur;
AVPacket pkt;
int ret = 0;
mfxVideoParam param = { { 0 } };
if (q->reinit_pending) {
close_decoder(q);
} else if (q->engine_ready) {
ret = MFXVideoDECODE_GetVideoParam(q->session, ¶m);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "MFX decode get param error %d\n", ret);
}
ret = MFXVideoDECODE_Reset(q->session, ¶m);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "MFX decode reset error %d\n", ret);
}
/* Free all frames*/
cur = q->work_frames;
while (cur) {
q->work_frames = cur->next;
av_frame_free(&cur->frame);
av_freep(&cur);
cur = q->work_frames;
}
}
/* Reset output surfaces */
av_fifo_reset(q->async_fifo);
/* Reset input packets fifo */
while (av_fifo_size(q->pkt_fifo)) {
av_fifo_generic_read(q->pkt_fifo, &pkt, sizeof(pkt), NULL);
av_packet_unref(&pkt);
}
/* Reset input bitstream fifo */
av_fifo_reset(q->input_fifo);
}
AVFifoBuffer *av_fifo_alloc(unsigned int size)
{
AVFifoBuffer *f= av_mallocz(sizeof(AVFifoBuffer));
if (!f)
return NULL;
f->buffer = av_malloc(size);
f->end = f->buffer + size;
av_fifo_reset(f);
if (!f->buffer)
av_freep(&f);
return f;
}
static AVFifoBuffer *fifo_alloc_common(void *buffer, size_t size)
{
AVFifoBuffer *f;
if (!buffer)
return NULL;
f = av_mallocz(sizeof(AVFifoBuffer));
if (!f) {
av_free(buffer);
return NULL;
}
f->buffer = buffer;
f->end = f->buffer + size;
av_fifo_reset(f);
return f;
}
static void mediacodec_decode_flush(AVCodecContext *avctx)
{
MediaCodecH264DecContext *s = avctx->priv_data;
while (av_fifo_size(s->fifo)) {
AVPacket pkt;
av_fifo_generic_read(s->fifo, &pkt, sizeof(pkt), NULL);
av_packet_unref(&pkt);
}
av_fifo_reset(s->fifo);
av_packet_unref(&s->filtered_pkt);
ff_mediacodec_dec_flush(avctx, &s->ctx);
}
void FFmpegDecoder::Close()
{
if (av && av->stream)
{
avcodec_close(av->stream->codec);
av->stream = NULL;
}
if (av && av->ctx)
{
avio_close(av->ctx->pb);
avformat_free_context(av->ctx);
av->ctx = NULL;
}
if (av && av->fifo)
av_fifo_reset(av->fifo);
if (av)
av->started = false;
}
int CacheHttp_Reset(void * handle)
{
av_log(NULL, AV_LOG_INFO, "--------------- CacheHttp_Reset begin");
if(!handle)
return AVERROR(EIO);
CacheHttpContext * s = (CacheHttpContext *)handle;
s->RESET = 1;
while(!s->EXITED && 0 == s->reset_flag) {
usleep(1000);
}
av_log(NULL, AV_LOG_INFO, "--------------- CacheHttp_Reset suc !");
pthread_mutex_lock(&s->read_mutex);
if(s->fifo)
av_fifo_reset(s->fifo);
pthread_mutex_unlock(&s->read_mutex);
s->RESET = 0;
s->finish_flag = 0;
return 0;
}
static void *start_smoothing( void *ptr )
{
obe_t *h = ptr;
int num_muxed_data = 0, buffer_complete = 0;
int64_t start_clock = -1, start_pcr, end_pcr, temporal_vbv_size = 0, cur_pcr;
obe_muxed_data_t **muxed_data = NULL, *start_data, *end_data;
AVFifoBuffer *fifo_data = NULL, *fifo_pcr = NULL;
uint8_t *output_buf;
struct sched_param param = {0};
param.sched_priority = 99;
pthread_setschedparam( pthread_self(), SCHED_FIFO, ¶m );
/* This thread buffers one VBV worth of frames */
fifo_data = av_fifo_alloc( TS_PACKETS_SIZE );
if( !fifo_data )
{
fprintf( stderr, "[mux-smoothing] Could not allocate data fifo" );
return NULL;
}
fifo_pcr = av_fifo_alloc( 7 * sizeof(int64_t) );
if( !fifo_pcr )
{
fprintf( stderr, "[mux-smoothing] Could not allocate pcr fifo" );
return NULL;
}
if( h->obe_system == OBE_SYSTEM_TYPE_GENERIC )
{
for( int i = 0; i < h->num_encoders; i++ )
{
if( h->encoders[i]->is_video )
{
pthread_mutex_lock( &h->encoders[i]->queue.mutex );
while( !h->encoders[i]->is_ready )
pthread_cond_wait( &h->encoders[i]->queue.in_cv, &h->encoders[i]->queue.mutex );
x264_param_t *params = h->encoders[i]->encoder_params;
temporal_vbv_size = av_rescale_q_rnd(
(int64_t)params->rc.i_vbv_buffer_size * params->rc.f_vbv_buffer_init,
(AVRational){1, params->rc.i_vbv_max_bitrate }, (AVRational){ 1, OBE_CLOCK }, AV_ROUND_UP );
pthread_mutex_unlock( &h->encoders[i]->queue.mutex );
break;
}
}
}
while( 1 )
{
pthread_mutex_lock( &h->mux_smoothing_queue.mutex );
while( h->mux_smoothing_queue.size == num_muxed_data && !h->cancel_mux_smoothing_thread )
pthread_cond_wait( &h->mux_smoothing_queue.in_cv, &h->mux_smoothing_queue.mutex );
if( h->cancel_mux_smoothing_thread )
{
pthread_mutex_unlock( &h->mux_smoothing_queue.mutex );
break;
}
num_muxed_data = h->mux_smoothing_queue.size;
/* Refill the buffer after a drop */
pthread_mutex_lock( &h->drop_mutex );
if( h->mux_drop )
{
syslog( LOG_INFO, "Mux smoothing buffer reset\n" );
h->mux_drop = 0;
av_fifo_reset( fifo_data );
av_fifo_reset( fifo_pcr );
buffer_complete = 0;
start_clock = -1;
}
pthread_mutex_unlock( &h->drop_mutex );
if( !buffer_complete )
{
start_data = h->mux_smoothing_queue.queue[0];
end_data = h->mux_smoothing_queue.queue[num_muxed_data-1];
start_pcr = start_data->pcr_list[0];
end_pcr = end_data->pcr_list[(end_data->len / 188)-1];
if( end_pcr - start_pcr >= temporal_vbv_size )
{
buffer_complete = 1;
start_clock = -1;
}
else
{
pthread_mutex_unlock( &h->mux_smoothing_queue.mutex );
continue;
}
}
//printf("\n mux smoothed frames %i \n", num_muxed_data );
muxed_data = malloc( num_muxed_data * sizeof(*muxed_data) );
if( !muxed_data )
{
pthread_mutex_unlock( &h->output_queue.mutex );
syslog( LOG_ERR, "Malloc failed\n" );
return NULL;
}
memcpy( muxed_data, h->mux_smoothing_queue.queue, num_muxed_data * sizeof(*muxed_data) );
pthread_mutex_unlock( &h->mux_smoothing_queue.mutex );
for( int i = 0; i < num_muxed_data; i++ )
{
if( av_fifo_realloc2( fifo_data, av_fifo_size( fifo_data ) + muxed_data[i]->len ) < 0 )
{
syslog( LOG_ERR, "Malloc failed\n" );
return NULL;
}
av_fifo_generic_write( fifo_data, muxed_data[i]->data, muxed_data[i]->len, NULL );
if( av_fifo_realloc2( fifo_pcr, av_fifo_size( fifo_pcr ) + ((muxed_data[i]->len * sizeof(int64_t)) / 188) ) < 0 )
{
syslog( LOG_ERR, "Malloc failed\n" );
return NULL;
}
av_fifo_generic_write( fifo_pcr, muxed_data[i]->pcr_list, (muxed_data[i]->len * sizeof(int64_t)) / 188, NULL );
remove_from_queue( &h->mux_smoothing_queue );
destroy_muxed_data( muxed_data[i] );
}
free( muxed_data );
muxed_data = NULL;
num_muxed_data = 0;
while( av_fifo_size( fifo_data ) >= TS_PACKETS_SIZE )
{
output_buf = malloc( TS_PACKETS_SIZE + 7 * sizeof(int64_t) );
if( !output_buf )
{
syslog( LOG_ERR, "Malloc failed\n" );
return NULL;
}
av_fifo_generic_read( fifo_pcr, output_buf, 7 * sizeof(int64_t), NULL );
av_fifo_generic_read( fifo_data, &output_buf[7 * sizeof(int64_t)], TS_PACKETS_SIZE, NULL );
cur_pcr = AV_RN64( output_buf );
if( start_clock != -1 )
{
sleep_input_clock( h, cur_pcr - start_pcr + start_clock );
}
if( start_clock == -1 )
{
start_clock = get_input_clock_in_mpeg_ticks( h );
start_pcr = cur_pcr;
}
if( add_to_queue( &h->output_queue, output_buf ) < 0 )
return NULL;
output_buf = NULL;
}
}
av_fifo_free( fifo_data );
av_fifo_free( fifo_pcr );
return NULL;
}
/**
* \brief stop playing and empty buffers (for seeking/pause)
*/
static void reset(void) {
paused = 1;
av_fifo_reset(buffer);
paused = 0;
}
static int do_qsv_decode(AVCodecContext *avctx, QSVContext *q,
AVFrame *frame, int *got_frame,
AVPacket *avpkt)
{
QSVFrame *out_frame;
mfxFrameSurface1 *insurf;
mfxFrameSurface1 *outsurf;
mfxSyncPoint sync;
mfxBitstream bs = { { { 0 } } };
int ret;
int n_out_frames;
int buffered = 0;
int flush = !avpkt->size || q->reinit_pending;
if (!q->engine_ready) {
ret = qsv_decode_init(avctx, q, avpkt);
if (ret)
return ret;
}
if (!flush) {
if (av_fifo_size(q->input_fifo)) {
/* we have got rest of previous packet into buffer */
if (av_fifo_space(q->input_fifo) < avpkt->size) {
ret = av_fifo_grow(q->input_fifo, avpkt->size);
if (ret < 0)
return ret;
}
av_fifo_generic_write(q->input_fifo, avpkt->data, avpkt->size, NULL);
bs.Data = q->input_fifo->rptr;
bs.DataLength = av_fifo_size(q->input_fifo);
buffered = 1;
} else {
bs.Data = avpkt->data;
bs.DataLength = avpkt->size;
}
bs.MaxLength = bs.DataLength;
bs.TimeStamp = avpkt->pts;
}
while (1) {
ret = get_surface(avctx, q, &insurf);
if (ret < 0)
return ret;
do {
ret = MFXVideoDECODE_DecodeFrameAsync(q->session, flush ? NULL : &bs,
insurf, &outsurf, &sync);
if (ret != MFX_WRN_DEVICE_BUSY)
break;
av_usleep(500);
} while (1);
if (MFX_WRN_VIDEO_PARAM_CHANGED==ret) {
/* TODO: handle here minor sequence header changing */
} else if (MFX_ERR_INCOMPATIBLE_VIDEO_PARAM==ret) {
av_fifo_reset(q->input_fifo);
flush = q->reinit_pending = 1;
continue;
}
if (sync) {
QSVFrame *out_frame = find_frame(q, outsurf);
if (!out_frame) {
av_log(avctx, AV_LOG_ERROR,
"The returned surface does not correspond to any frame\n");
return AVERROR_BUG;
}
out_frame->queued = 1;
av_fifo_generic_write(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
continue;
}
if (MFX_ERR_MORE_SURFACE != ret && ret < 0)
break;
}
/* make sure we do not enter an infinite loop if the SDK
* did not consume any data and did not return anything */
if (!sync && !bs.DataOffset && !flush) {
av_log(avctx, AV_LOG_WARNING, "A decode call did not consume any data\n");
bs.DataOffset = avpkt->size;
}
if (buffered) {
qsv_fifo_relocate(q->input_fifo, bs.DataOffset);
} else if (bs.DataOffset!=avpkt->size) {
/* some data of packet was not consumed. store it to local buffer */
av_fifo_generic_write(q->input_fifo, avpkt->data+bs.DataOffset,
avpkt->size - bs.DataOffset, NULL);
}
if (MFX_ERR_MORE_DATA!=ret && ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Error %d during QSV decoding.\n", ret);
return ff_qsv_error(ret);
}
n_out_frames = av_fifo_size(q->async_fifo) / (sizeof(out_frame)+sizeof(sync));
if (n_out_frames > q->async_depth || (flush && n_out_frames) ) {
AVFrame *src_frame;
av_fifo_generic_read(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
out_frame->queued = 0;
MFXVideoCORE_SyncOperation(q->session, sync, 60000);
src_frame = out_frame->frame;
ret = av_frame_ref(frame, src_frame);
if (ret < 0)
return ret;
outsurf = out_frame->surface;
frame->pkt_pts = frame->pts = outsurf->Data.TimeStamp;
frame->repeat_pict =
outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_TRIPLING ? 4 :
outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_DOUBLING ? 2 :
outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_REPEATED ? 1 : 0;
frame->top_field_first =
outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_TFF;
frame->interlaced_frame =
!(outsurf->Info.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
*got_frame = 1;
}
return avpkt->size;
}
int main(void)
{
/* create a FIFO buffer */
AVFifoBuffer *fifo = av_fifo_alloc(13 * sizeof(int));
int i, j, n, *p;
/* fill data */
for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++)
av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
/* peek at FIFO */
n = av_fifo_size(fifo) / sizeof(int);
for (i = -n + 1; i < n; i++) {
int *v = (int *)av_fifo_peek2(fifo, i * sizeof(int));
printf("%d: %d\n", i, *v);
}
printf("\n");
/* peek_at at FIFO */
n = av_fifo_size(fifo) / sizeof(int);
for (i = 0; i < n; i++) {
av_fifo_generic_peek_at(fifo, &j, i * sizeof(int), sizeof(j), NULL);
printf("%d: %d\n", i, j);
}
printf("\n");
/* generic peek at FIFO */
n = av_fifo_size(fifo);
p = malloc(n);
if (p == NULL) {
fprintf(stderr, "failed to allocate memory.\n");
exit(1);
}
(void) av_fifo_generic_peek(fifo, p, n, NULL);
/* read data at p */
n /= sizeof(int);
for(i = 0; i < n; ++i)
printf("%d: %d\n", i, p[i]);
putchar('\n');
/* read data */
for (i = 0; av_fifo_size(fifo) >= sizeof(int); i++) {
av_fifo_generic_read(fifo, &j, sizeof(int), NULL);
printf("%d ", j);
}
printf("\n");
/* test *ndx overflow */
av_fifo_reset(fifo);
fifo->rndx = fifo->wndx = ~(uint32_t)0 - 5;
/* fill data */
for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++)
av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
/* peek_at at FIFO */
n = av_fifo_size(fifo) / sizeof(int);
for (i = 0; i < n; i++) {
av_fifo_generic_peek_at(fifo, &j, i * sizeof(int), sizeof(j), NULL);
printf("%d: %d\n", i, j);
}
putchar('\n');
/* test fifo_grow */
(void) av_fifo_grow(fifo, 15 * sizeof(int));
/* fill data */
n = av_fifo_size(fifo) / sizeof(int);
for (i = n; av_fifo_space(fifo) >= sizeof(int); ++i)
av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
/* peek_at at FIFO */
n = av_fifo_size(fifo) / sizeof(int);
for (i = 0; i < n; i++) {
av_fifo_generic_peek_at(fifo, &j, i * sizeof(int), sizeof(j), NULL);
printf("%d: %d\n", i, j);
}
av_fifo_free(fifo);
free(p);
return 0;
}
/* set variables and buffer to initial state */
static void reset(void)
{
audio_pause();
av_fifo_reset(ao->buffer);
}
