static OSStatus InputProc(void *inRefCon, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList * ioData) { UNUSED(ioData); struct state_ca_capture * s = (struct state_ca_capture *) inRefCon; OSStatus err =noErr; err= AudioUnitRender(s->auHALComponentInstance, ioActionFlags, inTimeStamp, inBusNumber, //will be '1' for input data inNumberFrames, //# of frames requested s->theBufferList); if(err == noErr) { int i; int len = inNumberFrames * s->audio_packet_size; for(i = 0; i < s->frame.ch_count; ++i) mux_channel(s->tmp, s->theBufferList->mBuffers[i].mData, s->frame.bps, len, s->frame.ch_count, i, 1.0); uint32_t write_bytes = len * s->frame.ch_count; #ifdef HAVE_SPEEX if(s->nominal_sample_rate != s->frame.sample_rate) { int err; uint32_t in_frames = inNumberFrames; err = speex_resampler_process_interleaved_int(s->resampler, (spx_int16_t *) s->tmp, &in_frames, (spx_int16_t *) s->resampled, &write_bytes); //speex_resampler_process_int(resampler, channelID, in, &in_length, out, &out_length); write_bytes *= s->frame.bps * s->frame.ch_count; if(err) { fprintf(stderr, "Resampling data error.\n"); return err; } } #endif pthread_mutex_lock(&s->lock); #ifdef HAVE_SPEEX if(s->nominal_sample_rate != s->frame.sample_rate) ring_buffer_write(s->buffer, s->resampled, write_bytes); else #endif ring_buffer_write(s->buffer, s->tmp, write_bytes); s->data_ready = TRUE; if(s->boss_waiting) pthread_cond_signal(&s->cv); pthread_mutex_unlock(&s->lock); } else { fprintf(stderr, "[CoreAudio] writing buffer caused error %i.\n", (int) err); } return err; }
uint32_t keyboard_write(fs_node_t *node, uint32_t offset, uint32_t size, uint8_t *buffer) { printk("going to insert %x (%p) into the keyboard buffer\n", buffer, buffer); return ring_buffer_write(devfs_keyboard->buffer, buffer); }
void g_at_mux_feed_dlc_data(GAtMux *mux, guint8 dlc, const void *data, int tofeed) { GAtMuxChannel *channel; int written; int offset; int bit; debug(mux, "deliver_data: dlc: %hu", dlc); if (dlc < 1 || dlc > MAX_CHANNELS) return; channel = mux->dlcs[dlc-1]; if (channel == NULL) return; written = ring_buffer_write(channel->buffer, data, tofeed); if (written < 0) return; offset = dlc / 8; bit = dlc % 8; mux->newdata[offset] |= 1 << bit; channel->condition |= G_IO_IN; }
u16 mip_interface_write(mip_interface *device_interface, u8 *data, u32 num_bytes, u32 *bytes_written) { u32 i; //Check that the parser is initialized if(device_interface->state != MIP_INTERFACE_INITIALIZED) return MIP_INTERFACE_ERROR; //Set the feedback of bytes written to zero *bytes_written = 0; //Zero byte write short circuit if(num_bytes == 0) return MIP_INTERFACE_OK; //Loop through the bytes and copy them to the ring buffer for(i=0; i<num_bytes; i++) { if(ring_buffer_write(&device_interface->input_buffer, &data[i], 1) == RING_BUFFER_OK) (*bytes_written)++; else break; } if(num_bytes != *bytes_written) return MIP_INTERFACE_ERROR; return MIP_INTERFACE_OK; }
inline size_t RingBuffer::Write(const void* buffer, size_t length) { if (fBuffer == NULL) return B_NO_MEMORY; return ring_buffer_write(fBuffer, (const uint8*)buffer, length); }
//Put packet into ring buffer uint8_t usart_send(const uint8_t* data, const uint8_t len) { uint8_t ret = 0; for(uint8_t i = 0; i < len; i++) { if(ring_buffer_write(tx_buff, data[i])) { ret = 1; break; } } UCSR0B |= (1<<UDRIE0); return ret; }
inline ssize_t RingBuffer::Write(const void* buffer, size_t length, bool isUser) { if (fBuffer == NULL) return B_NO_MEMORY; if (isUser && !IS_USER_ADDRESS(buffer)) return B_BAD_ADDRESS; return isUser ? ring_buffer_user_write(fBuffer, (const uint8*)buffer, length) : ring_buffer_write(fBuffer, (const uint8*)buffer, length); }
static void sound_sdl_write(SoundDriver *driver, guint16 * finalWave, int length) { g_assert(driver != NULL); DriverData *data = (DriverData *)driver->driverData; if (!data->_initialized) return; if (SDL_GetAudioStatus() != SDL_AUDIO_PLAYING) SDL_PauseAudio(0); SDL_LockMutex(data->_mutex); unsigned int samples = length / 4; int avail; while ((avail = ring_buffer_avail(data->_rbuf) / 4) < samples) { ring_buffer_write(data->_rbuf, finalWave, avail * 4); finalWave += avail * 2; samples -= avail; // If emulating and not in speed up mode, synchronize to audio // by waiting till there is enough room in the buffer if (data->sync) { SDL_CondWait(data->_cond, data->_mutex); } else { // Drop the remaining of the audio data SDL_UnlockMutex(data->_mutex); return; } } ring_buffer_write(data->_rbuf, finalWave, samples * 4); SDL_UnlockMutex(data->_mutex); }
static void display_deltacast_put_audio_frame(void *state, struct audio_frame *frame) { struct state_deltacast *s = (struct state_deltacast *)state; int i; int channel_len = frame->data_len / frame->ch_count; pthread_mutex_lock(&s->lock); for(i = 0; i < frame->ch_count; ++i) { demux_channel(s->audio_tmp, frame->data, frame->bps, frame->data_len, frame->ch_count, i); ring_buffer_write(s->audio_channels[i], s->audio_tmp, channel_len); } pthread_mutex_unlock(&s->lock); }
void FuartInterrupt(void) { int status; uint8_t rxData; status = FuartIOctl(UART_IOCTL_RXSTAT_GET,0); if(status & 0x1E){ /* * clear FIFO before clear other flags */ FuartIOctl(UART_IOCTL_RXFIFO_CLR,0); /* * clear other error flags */ FuartIOctl(UART_IOCTL_RXINT_CLR,0); } if(status & 0x01) { //or,you can receive them in the interrupt directly while(FuartRecvByte(&rxData) > 0){ ring_buffer_write( uart_interfaces[ AP80xx_FUART ].rx_buffer, &rxData,1 ); } FuartIOctl(UART_IOCTL_RXINT_CLR,0); // Notify thread if sufficient data are available if ( ( uart_interfaces[ 0 ].rx_size > 0 ) && ( ring_buffer_used_space( uart_interfaces[ AP80xx_FUART ].rx_buffer ) >= uart_interfaces[ AP80xx_FUART ].rx_size ) ) { #ifndef NO_MICO_RTOS mico_rtos_set_semaphore( &uart_interfaces[ AP80xx_FUART ].rx_complete ); #else uart_interfaces[ AP80xx_FUART ].rx_complete = true; #endif uart_interfaces[ AP80xx_FUART ].rx_size = 0; } } if(FuartIOctl(UART_IOCTL_TXSTAT_GET,0) & 0x01) { FuartIOctl(UART_IOCTL_TXINT_CLR,0); #ifndef NO_MICO_RTOS mico_rtos_set_semaphore( &uart_interfaces[ AP80xx_FUART ].tx_complete ); #else uart_interfaces[ AP80xx_FUART ].tx_complete = true; #endif } }
static int jack_process_callback(jack_nframes_t nframes, void *arg) { struct state_jack_capture *s = (struct state_jack_capture *) arg; int i; int channel_size = nframes * sizeof(int32_t); for (i = 0; i < s->frame.ch_count; ++i) { jack_default_audio_sample_t *in = jack_port_get_buffer(s->input_ports[i], nframes); float2int((char *) in, (char *) in, channel_size); mux_channel(s->tmp, (char *) in, sizeof(int32_t), channel_size, s->frame.ch_count, i); } ring_buffer_write(s->data, s->tmp, channel_size * s->frame.ch_count); return 0; }
void platform_uart_irq( platform_uart_driver_t* driver ) { platform_uart_port_t* uart = (platform_uart_port_t*) driver->interface->uart_base; uint8_t data=0; while (Chip_UART_GetLineStatus(uart) & UART_LSR_RDR) { Chip_UART_ReceiveByte(uart,&data); ring_buffer_write( driver->rx_buffer,&data, 1 ); } // Notify thread if sufficient data are available if ( ( driver->rx_size > 0 ) && ( ring_buffer_used_space( driver->rx_buffer ) >= driver->rx_size ) ) { host_rtos_set_semaphore( &driver->rx_complete, WICED_TRUE ); driver->rx_size = 0; } }
void main() { char temp[100]; uint16_t len; ring_buffer_init(&ring, buffer, BUFFER_SIZE); len = ring_buffer_readline(&ring, temp, 100); printf("%d - %s\n", len, temp); strcpy(temp, "line1\nline2\nline3"); ring_buffer_write(&ring, temp, strlen(temp)); while((len = ring_buffer_readline(&ring, temp, 100)) > 0) { printf("%d - %s\n", len, temp); } printf("available: %d\n", ring.available); ring_buffer_write_byte(&ring, '\n'); while((len = ring_buffer_readline(&ring, temp, 100)) > 0) { printf("%d - %s\n", len, temp); } }
static int write_data(void *opaque, uint8_t *buf, int buf_size) { int ret = 0; RingBufferContext *ctx = (RingBufferContext*)opaque; int freesize = ring_buffer_freesize(ctx); //printf("\nfreesize = %d\n\n", freesize); int size = freesize; if(size <= 0) return 0; else if(size >= buf_size) size = buf_size; else FFMPEG_WARN("avio write %p to %p, writesize=%d, freesize=%d, rest=%d", buf, opaque, buf_size, freesize, freesize-buf_size); ret = ring_buffer_write(ctx, buf, size); if(ret == 0) ret = size; else ret = 0; return ret; }
static PyObject * Buffer_write(Buffer *self, PyObject *args, PyObject *kwargs) { char *data; int count_bytes; static char *kwlist[] = {"data", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#", kwlist, &data, &count_bytes)) return NULL; if (self->closed) { PyErr_SetString (PyExc_ValueError, "I/O operation on closed file"); return NULL; } int available_bytes = ring_buffer_count_free_bytes (self->buffer); if (available_bytes < count_bytes) { PyErr_SetString(FullError, "Not enough free bytes to write"); return NULL; } ring_buffer_write (self->buffer, data, count_bytes); return Py_None; }
/** * __buffer_add_sample - add a new latency sample recording to the ring buffer * @sample: The new latency sample value * * This receives a new latency sample and records it in a global ring buffer. * No additional locking is used in this case - suited for stop_machine use. */ static int __buffer_add_sample(struct sample *sample) { return ring_buffer_write(ring_buffer, sizeof(struct sample), sample); }
void ir_in_recive_handler(void) { uint32 status; uint32 time_cnt; uint32 time_cur; status = GPIOIntStatus(IR_IN_PORT, 1); GPIOIntClear(IR_IN_PORT, status); if(GPIO_ReadSinglePin(IR_IN_PORT, IR_IN_PIN)){ SET_IR_OUT(1); }else{ SET_IR_OUT(0); return; } time_cur = bsp_timer0_get_time(); time_cnt = time_cur - ir_jack.last_time; ir_jack.last_time = time_cur; gIr_timeout = 0; switch(ir_jack.state){ case NEC_IDLE: ir_jack.state = NEC_LEADER; break; case NEC_LEADER: if(time_cnt < LEADER_TIME_MAX && time_cnt > LEADER_TIME_MIN){ ir_jack.code.val = 0; ir_jack.bitcnt = 0; ir_jack.state = NEC_CODE; }else{ ir_jack.state = NEC_IDLE; } break; case NEC_CODE: if(time_cnt < ONE_TIME_MAX && time_cnt > ZERO_TIME_MIN){ ir_jack.bitcnt++; ir_jack.code.val >>= 1; if(time_cnt >= MEDIAN_BIT_TIME){ ir_jack.code.val |= 0x80000000; } } if(ir_jack.bitcnt == 32){ SYS_TRACE("jack ir code =[%x],LB=%2x, HB=%2x, UB=%2x, MB=%2x \r\n", ir_jack.code.val, ir_jack.code.byte.LB, ir_jack.code.byte.HB, ir_jack.code.byte.UB, ir_jack.code.byte.MB); if((ir_jack.code.byte.LB == CUSTMER_CODE_LB) && (ir_jack.code.byte.HB == CUSTMET_CODE_HB)){ if((ir_jack.code.byte.MB & ir_jack.code.byte.UB) == 0){ ring_buffer_write(IR_BACK_IN, ir_jack.code.byte.UB); ir_jack.bitcnt = 0; ir_jack.state = NEC_REPEATE1; if((ir_commond[IR_VOL_UP] == ir_jack.code.byte.UB) || (ir_commond[IR_LFET] == ir_jack.code.byte.UB) || (ir_commond[IR_RIGHT]== ir_jack.code.byte.UB) || (ir_commond[IR_VOL_DOWN] == ir_jack.code.byte.UB)){ repeat_thres = 5; repeat_commond = ir_jack.code.byte.UB; }else{ repeat_thres = 0; repeat_commond = 0; } ir_jack.code.val = 0; }else{ ir_jack.state = NEC_IDLE; } }else{ ir_jack.state = NEC_IDLE; } } break; case NEC_REPEATE1: ir_jack.state = NEC_REPEATE2; break; case NEC_REPEATE2: if(time_cnt <= REPEAT_TIME_MAX && time_cnt >= REPEAT_TIME_MIN){ if(repeat_commond){ ir_jack.state = NEC_REPEATE1; if(repeat_thres){ repeat_thres--; }else{ ring_buffer_write(IR_BACK_IN, repeat_commond); } }else{ ir_jack.state = NEC_IDLE; } } break; default: break; }
ssize_t RingBuffer::Write(const void *buffer, size_t size) { return ring_buffer_write(fBuffer, (uint8*)buffer, size); }
static struct audio_desc audio_play_jack_query_format(void *state, struct audio_desc desc) { struct state_jack_playback *s = (struct state_jack_playback *) state; return (struct audio_desc){4, s->jack_sample_rate, min(s->jack_ports_count, desc.ch_count), AC_PCM}; } static int audio_play_jack_reconfigure(void *state, struct audio_desc desc) { struct state_jack_playback *s = (struct state_jack_playback *) state; const char **ports; int i; assert(desc.bps == 4 && desc.sample_rate == s->jack_sample_rate && desc.codec == AC_PCM); jack_deactivate(s->client); ports = jack_get_ports(s->client, s->jack_ports_pattern, NULL, JackPortIsInput); if(ports == NULL) { fprintf(stderr, "[JACK playback] Unable to input ports matching %s.\n", s->jack_ports_pattern); return FALSE; } if(desc.ch_count > s->jack_ports_count) { fprintf(stderr, "[JACK playback] Warning: received %d audio channels, JACK can process only %d.", desc.ch_count, s->jack_ports_count); } for(i = 0; i < MAX_PORTS; ++i) { ring_buffer_destroy(s->data[i]); s->data[i] = NULL; } /* for all channels previously connected */ for(i = 0; i < desc.ch_count; ++i) { jack_disconnect(s->client, jack_port_name (s->output_port[i]), ports[i]); fprintf(stderr, "[JACK playback] Port %d: %s\n", i, ports[i]); } free(s->channel); free(s->converted); s->desc.bps = desc.bps; s->desc.ch_count = desc.ch_count; s->desc.sample_rate = desc.sample_rate; s->channel = malloc(s->desc.bps * desc.sample_rate); s->converted = (float *) malloc(desc.sample_rate * sizeof(float)); for(i = 0; i < desc.ch_count; ++i) { s->data[i] = ring_buffer_init(sizeof(float) * s->jack_sample_rate); } if(jack_activate(s->client)) { fprintf(stderr, "[JACK capture] Cannot activate client.\n"); return FALSE; } for(i = 0; i < desc.ch_count; ++i) { if (jack_connect (s->client, jack_port_name (s->output_port[i]), ports[i])) { fprintf (stderr, "Cannot connect output port: %d.\n", i); return FALSE; } } free(ports); return TRUE; } static void audio_play_jack_put_frame(void *state, struct audio_frame *frame) { struct state_jack_playback *s = (struct state_jack_playback *) state; assert(frame->bps == 4); int channel_size = frame->data_len / frame->ch_count; for (int i = 0; i < frame->ch_count; ++i) { demux_channel(s->channel, frame->data, frame->bps, frame->data_len, frame->ch_count, i); int2float((char *) s->converted, (char *) s->channel, channel_size); ring_buffer_write(s->data[i], (char *) s->converted, channel_size); } } static void audio_play_jack_done(void *state) { struct state_jack_playback *s = (struct state_jack_playback *) state; int i; jack_client_close(s->client); free(s->channel); free(s->converted); free(s->jack_ports_pattern); for(i = 0; i < MAX_PORTS; ++i) { ring_buffer_destroy(s->data[i]); } free(s); } static const struct audio_playback_info aplay_jack_info = { audio_play_jack_help, audio_play_jack_init, audio_play_jack_put_frame, audio_play_jack_query_format, audio_play_jack_reconfigure, audio_play_jack_done }; REGISTER_MODULE(jack, &aplay_jack_info, LIBRARY_CLASS_AUDIO_PLAYBACK, AUDIO_PLAYBACK_ABI_VERSION);
void usb_write(const uint8_t* data, uint16_t len) { ring_buffer_write(&usb_tx_ring_buffer, data, len); }
int CFfmpeg::ReadData(int nNeed, unsigned char* pBuffer, int* pnRead) { int buffer_read = 0; int ret; AVPacket pkt; pthread_mutex_lock(&iolock); if(!transcode) { ret = fread(pBuffer, 1, nNeed, m_pFp); if(ret<=0) { FFMPEG_ERROR("fread: %s", strerror(errno)); } else { curpos += ret; buffer_read = ret; } } else { while(1) { ret = ring_buffer_datasize(&outputringbuffer); if(ret > 0) { int reqsize = nNeed - buffer_read; if(ret < reqsize) reqsize = ret; ret = ring_buffer_read(&outputringbuffer, pBuffer+buffer_read, reqsize); if(ret == 0) { buffer_read += reqsize; } } if(buffer_read >= nNeed) break; ret = av_read_frame(infmt_ctx, &pkt); if(ret == AVERROR_EOF) { FFMPEG_INFO("=== AVERROR_EOF"); eof = 1; *pnRead = buffer_read; //pthread_mutex_lock(&iolock); curpos = avio_seek(infmt_ctx->pb, 0, SEEK_CUR); pthread_mutex_unlock(&iolock); return buffer_read; } else if(ret == AVERROR(EAGAIN)) { continue; } else if(ret < 0) { FFMPEG_WARN("av_read_frame return %d", ret); *pnRead = buffer_read; //pthread_mutex_lock(&iolock); curpos = avio_seek(infmt_ctx->pb, 0, SEEK_CUR); pthread_mutex_unlock(&iolock); return buffer_read; } else if(ret >= 0) { AVStream *ost, *ist; AVFrame avframe; AVPacket opkt; int64_t pts_base; av_init_packet(&opkt); //opkt = pkt; if(pkt.stream_index == video) { ost = vst; ist = infmt_ctx->streams[video]; opkt.stream_index = vst->index; pts_base = vdts_base; //printf("pts=%lld, dts=%lld, duration=%d\n", pkt.pts, pkt.dts, pkt.duration); } else if(pkt.stream_index == audio1) { ost = ast1; ist = infmt_ctx->streams[audio1]; opkt.stream_index = ast1->index; pts_base = a1dts_base; if(acodec1) { uint8_t outbuffer[4096]; int sample_size = sizeof(adecbuffer1); int frame_size = ost->codec->frame_size * 4; //FFMPEG_DEBUG("before decode, pts=0x%llx, dts=0x%llx", pkt.pts, pkt.dts); avcodec_decode_audio3(ist->codec, adecbuffer1, &sample_size, &pkt); //FFMPEG_DEBUG("after decode, pts=0x%llx, dts=0x%llx", pkt.pts, pkt.dts); ring_buffer_write(&adecrbuffer1, (uint8_t*)adecbuffer1, sample_size); while(ring_buffer_datasize(&adecrbuffer1) > frame_size) { av_init_packet(&opkt); ring_buffer_read(&adecrbuffer1, (uint8_t*)adecbuffer1, frame_size); ret = avcodec_encode_audio(ost->codec, outbuffer, sizeof(outbuffer), adecbuffer1); //printf("ret=%d\n", ret); opkt.data = outbuffer; opkt.size = ret; opkt.stream_index = ast1->index; if(pkt.pts != AV_NOPTS_VALUE) opkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base)+pts_base; else opkt.pts = AV_NOPTS_VALUE; if (pkt.dts != AV_NOPTS_VALUE) opkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base)+pts_base; else opkt.dts = av_rescale_q(pkt.dts, AV_TIME_BASE_Q, ost->time_base)+pts_base; opkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base); opkt.flags |= AV_PKT_FLAG_KEY; //FFMPEG_DEBUG("audio1 rescaled, pts=0x%llx, dts=0x%llx", opkt.pts, opkt.dts); ret = av_interleaved_write_frame(oc, &opkt); if(ret != 0) { FFMPEG_ERROR("av_interleaved_write_frame ret %d", ret); } ost->codec->frame_number++; av_free_packet(&opkt); } av_free_packet(&pkt); continue; } } else if(pkt.stream_index == audio2) { ost = ast2; ist = infmt_ctx->streams[audio2]; opkt.stream_index = ast2->index; pts_base = a2dts_base; if(acodec2) { uint8_t outbuffer[4096]; int sample_size = sizeof(adecbuffer1); int frame_size = ost->codec->frame_size * 4; avcodec_decode_audio3(ist->codec, adecbuffer2, &sample_size, &pkt); ring_buffer_write(&adecrbuffer2, (uint8_t*)adecbuffer2, sample_size); while(ring_buffer_datasize(&adecrbuffer2) > frame_size) { av_init_packet(&opkt); ring_buffer_read(&adecrbuffer2, (uint8_t*)adecbuffer2, frame_size); ret = avcodec_encode_audio(ost->codec, outbuffer, sizeof(outbuffer), adecbuffer2); //printf("ret=%d\n", ret); opkt.data = outbuffer; opkt.size = ret; opkt.stream_index = ast2->index; if(pkt.pts != AV_NOPTS_VALUE) opkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base)+pts_base; else opkt.pts = AV_NOPTS_VALUE; if (pkt.dts != AV_NOPTS_VALUE) opkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base)+pts_base; else opkt.dts = av_rescale_q(pkt.dts, AV_TIME_BASE_Q, ost->time_base)+pts_base; opkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base); opkt.flags |= AV_PKT_FLAG_KEY; ret = av_interleaved_write_frame(oc, &opkt); if(ret != 0) { FFMPEG_ERROR("av_interleaved_write_frame ret %d", ret); } ost->codec->frame_number++; av_free_packet(&opkt); } av_free_packet(&pkt); continue; } } else { av_free_packet(&pkt); continue; } avcodec_get_frame_defaults(&avframe); ost->codec->coded_frame = &avframe; avframe.key_frame = pkt.flags & AV_PKT_FLAG_KEY; if(pkt.pts != AV_NOPTS_VALUE) opkt.pts = av_rescale_q(pkt.pts, ist->time_base, ost->time_base)+pts_base; else opkt.pts = AV_NOPTS_VALUE; if (pkt.dts != AV_NOPTS_VALUE) opkt.dts = av_rescale_q(pkt.dts, ist->time_base, ost->time_base)+pts_base; else opkt.dts = av_rescale_q(pkt.dts, AV_TIME_BASE_Q, ost->time_base)+pts_base; opkt.duration = av_rescale_q(pkt.duration, ist->time_base, ost->time_base); opkt.data = pkt.data; opkt.size = pkt.size; if(bsfc && pkt.stream_index == video) { //printf("rescale pts=%lld, dts=%lld, duration=%d\n", opkt.pts, opkt.dts, opkt.duration); AVPacket new_pkt = opkt; int a = av_bitstream_filter_filter(bsfc, ost->codec, NULL, &new_pkt.data, &new_pkt.size, opkt.data, opkt.size, opkt.flags & AV_PKT_FLAG_KEY); if(a>0) { av_free_packet(&opkt); new_pkt.destruct = av_destruct_packet; } else if(a<0) { FFMPEG_ERROR("av_bitstream_filter_filter ret %d", a); } opkt = new_pkt; } ret = av_interleaved_write_frame(oc, &opkt); if(ret != 0) { FFMPEG_ERROR("av_interleaved_write_frame ret %d", ret); } ost->codec->frame_number++; } av_free_packet(&pkt); } curpos = avio_seek(infmt_ctx->pb, 0, SEEK_CUR); } *pnRead = buffer_read; pthread_mutex_unlock(&iolock); return buffer_read; }