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;
}
