static void dec_process(MSFilter *f){
DecData *d=(DecData*)f->data;
mblk_t *im;
MSQueue nalus;
AVFrame orig;
ms_queue_init(&nalus);
while((im=ms_queue_get(f->inputs[0]))!=NULL){
/*push the sps/pps given in sprop-parameter-sets if any*/
if (d->packet_num==0 && d->sps && d->pps){
mblk_set_timestamp_info(d->sps,mblk_get_timestamp_info(im));
mblk_set_timestamp_info(d->pps,mblk_get_timestamp_info(im));
rfc3984_unpack(&d->unpacker,d->sps,&nalus);
rfc3984_unpack(&d->unpacker,d->pps,&nalus);
d->sps=NULL;
d->pps=NULL;
}
rfc3984_unpack(&d->unpacker,im,&nalus);
if (!ms_queue_empty(&nalus)){
int size;
uint8_t *p,*end;
bool_t need_reinit=FALSE;
size=nalusToFrame(d,&nalus,&need_reinit);
if (need_reinit)
dec_reinit(d);
p=d->bitstream;
end=d->bitstream+size;
while (end-p>0) {
int len;
int got_picture=0;
AVPacket pkt;
avcodec_get_frame_defaults(&orig);
av_init_packet(&pkt);
pkt.data = p;
pkt.size = end-p;
len=avcodec_decode_video2(&d->av_context,&orig,&got_picture,&pkt);
if (len<=0) {
ms_warning("ms_AVdecoder_process: error %i.",len);
if ((f->ticker->time - d->last_error_reported_time)>5000 || d->last_error_reported_time==0) {
d->last_error_reported_time=f->ticker->time;
ms_filter_notify_no_arg(f,MS_VIDEO_DECODER_DECODING_ERRORS);
}
break;
}
if (got_picture) {
ms_queue_put(f->outputs[0],get_as_yuvmsg(f,d,&orig));
if (!d->first_image_decoded) {
ms_filter_notify_no_arg(f,MS_VIDEO_DECODER_FIRST_IMAGE_DECODED);
d->first_image_decoded = TRUE;
}
}
p+=len;
}
}
d->packet_num++;
}
}
static void player_process(MSFilter *f){
PlayerData *d=(PlayerData*)f->data;
int bytes=2*(f->ticker->interval*d->rate*d->nchannels)/1000;
ms_filter_lock(f);
if (d->state==STARTED){
int err;
mblk_t *om=allocb(bytes,0);
if (d->pause_time>0){
err=bytes;
memset(om->b_wptr,0,bytes);
d->pause_time-=f->ticker->interval;
}else{
err=read(d->fd,om->b_wptr,bytes);
if (d->swap) swap_bytes(om->b_wptr,bytes);
}
if (err>=0){
if (err!=0){
om->b_wptr+=bytes;
ms_queue_put(f->outputs[0],om);
}else freemsg(om);
if (err<bytes){
ms_filter_notify_no_arg(f,MS_FILE_PLAYER_EOF);
if (d->loop_after>=0){
lseek(d->fd,d->hsize,SEEK_SET);
d->pause_time=d->loop_after;
}else d->state=STOPPED;
}
}else{
ms_warning("Fail to read %i bytes: %s",bytes,strerror(errno));
}
}
ms_filter_unlock(f);
}
static mblk_t *get_as_yuvmsg(MSFilter *f, DecData *s, AVFrame *orig){
AVCodecContext *ctx=&s->av_context;
if (s->outbuf.w!=ctx->width || s->outbuf.h!=ctx->height){
if (s->sws_ctx!=NULL){
sws_freeContext(s->sws_ctx);
s->sws_ctx=NULL;
freemsg(s->yuv_msg);
s->yuv_msg=NULL;
}
ms_message("Getting yuv picture of %ix%i",ctx->width,ctx->height);
s->yuv_msg=ms_yuv_buf_alloc(&s->outbuf,ctx->width,ctx->height);
s->outbuf.w=ctx->width;
s->outbuf.h=ctx->height;
s->sws_ctx=sws_getContext(ctx->width,ctx->height,ctx->pix_fmt,
ctx->width,ctx->height,PIX_FMT_YUV420P,SWS_FAST_BILINEAR,
NULL, NULL, NULL);
ms_filter_notify_no_arg(f,MS_FILTER_OUTPUT_FMT_CHANGED);
}
#if LIBSWSCALE_VERSION_INT >= AV_VERSION_INT(0,9,0)
if (sws_scale(s->sws_ctx,(const uint8_t * const *)orig->data,orig->linesize, 0,
ctx->height, s->outbuf.planes, s->outbuf.strides)<0){
#else
if (sws_scale(s->sws_ctx,(uint8_t **)orig->data,orig->linesize, 0,
ctx->height, s->outbuf.planes, s->outbuf.strides)<0){
#endif
ms_error("%s: error in sws_scale().",f->desc->name);
}
return dupmsg(s->yuv_msg);
}
static void update_sps(DecData *d, mblk_t *sps){
if (d->sps)
freemsg(d->sps);
d->sps=dupb(sps);
}
static void update_pps(DecData *d, mblk_t *pps){
if (d->pps)
freemsg(d->pps);
if (pps) d->pps=dupb(pps);
else d->pps=NULL;
}
static bool_t check_sps_change(DecData *d, mblk_t *sps){
bool_t ret=FALSE;
if (d->sps){
ret=(msgdsize(sps)!=msgdsize(d->sps)) || (memcmp(d->sps->b_rptr,sps->b_rptr,msgdsize(sps))!=0);
if (ret) {
ms_message("SPS changed ! %i,%i",(int)msgdsize(sps),(int)msgdsize(d->sps));
update_sps(d,sps);
update_pps(d,NULL);
}
} else {
ms_message("Receiving first SPS");
update_sps(d,sps);
}
return ret;
}
static void player_process(MSFilter *f){
PlayerData *d=(PlayerData*)f->data;
int nsamples=(f->ticker->interval*d->rate*d->nchannels)/1000;
int bytes;
/*send an even number of samples each tick. At 22050Hz the number of samples per 10 ms chunk is odd.
Odd size buffer of samples cause troubles to alsa. Fixing in alsa is difficult, so workaround here.
*/
if (nsamples & 0x1 ) { //odd number of samples
if (d->count & 0x1 )
nsamples++;
else
nsamples--;
}
bytes=2*nsamples;
d->count++;
ms_filter_lock(f);
if (d->state==STARTED){
int err;
mblk_t *om=allocb(bytes,0);
if (d->pause_time>0){
err=bytes;
memset(om->b_wptr,0,bytes);
d->pause_time-=f->ticker->interval;
}else{
err=read(d->fd,om->b_wptr,bytes);
if (d->swap) swap_bytes(om->b_wptr,bytes);
}
if (err>=0){
if (err!=0){
if (err<bytes)
memset(om->b_wptr+err,0,bytes-err);
om->b_wptr+=bytes;
ms_queue_put(f->outputs[0],om);
}else freemsg(om);
if (err<bytes){
ms_filter_notify_no_arg(f,MS_FILE_PLAYER_EOF);
lseek(d->fd,d->hsize,SEEK_SET);
/* special value for playing file only once */
if (d->loop_after==-2)
{
d->state=STOPPED;
ms_filter_unlock(f);
return;
}
if (d->loop_after>=0){
d->pause_time=d->loop_after;
}
}
}else{
ms_warning("Fail to read %i bytes: %s",bytes,strerror(errno));
}
}
ms_filter_unlock(f);
}
static void h264_dec_output_cb(VTH264DecCtx *ctx, void *sourceFrameRefCon,
OSStatus status, VTDecodeInfoFlags infoFlags, CVImageBufferRef imageBuffer,
CMTime presentationTimeStamp, CMTime presentationDuration ) {
CGSize vsize;
MSPicture pixbuf_desc;
mblk_t *pixbuf = NULL;
uint8_t *src_planes[4] = { NULL };
int src_strides[4] = { 0 };
size_t i;
if(status != noErr || imageBuffer == NULL) {
ms_error("VideoToolboxDecoder: fail to decode one frame: error %d", status);
ms_filter_notify_no_arg(ctx->f, MS_VIDEO_DECODER_DECODING_ERRORS);
ms_filter_lock(ctx->f);
if(ctx->enable_avpf) {
ms_error("VideoToolboxDecoder: sending PLI");
ms_filter_notify_no_arg(ctx->f, MS_VIDEO_DECODER_SEND_PLI);
}
ms_filter_unlock(ctx->f);
return;
}
vsize = CVImageBufferGetEncodedSize(imageBuffer);
ctx->vsize.width = (int)vsize.width;
ctx->vsize.height = (int)vsize.height;
pixbuf = ms_yuv_buf_allocator_get(ctx->pixbuf_allocator, &pixbuf_desc, (int)vsize.width, (int)vsize.height);
CVPixelBufferLockBaseAddress(imageBuffer, kCVPixelBufferLock_ReadOnly);
for(i=0; i<3; i++) {
src_planes[i] = CVPixelBufferGetBaseAddressOfPlane(imageBuffer, i);
src_strides[i] = (int)CVPixelBufferGetBytesPerRowOfPlane(imageBuffer, i);
}
ms_yuv_buf_copy(src_planes, src_strides, pixbuf_desc.planes, pixbuf_desc.strides, ctx->vsize);
CVPixelBufferUnlockBaseAddress(imageBuffer, kCVPixelBufferLock_ReadOnly);
ms_mutex_lock(&ctx->mutex);
ms_queue_put(&ctx->queue, pixbuf);
ms_mutex_unlock(&ctx->mutex);
}
static void rec_process(MSFilter *f){
RecState *s=(RecState*)f->data;
mblk_t *m;
int err;
while((m=ms_queue_get(f->inputs[0]))!=NULL){
mblk_t *it=m;
ms_mutex_lock(&f->lock);
if (s->state==MSRecorderRunning){
while(it!=NULL){
int len=(int)(it->b_wptr-it->b_rptr);
int max_size_reached = 0;
if (s->max_size!=0 && s->size+len > s->max_size) {
len = s->max_size - s->size;
max_size_reached = 1;
}
if (s->swap) swap_bytes(it->b_wptr,len);
if ((err=write(s->fd,it->b_rptr,len))!=len){
if (err<0)
ms_warning("MSFileRec: fail to write %i bytes: %s",len,strerror(errno));
}
it=it->b_cont;
s->size+=len;
if (max_size_reached) {
ms_warning("MSFileRec: Maximum size (%d) has been reached. closing file.",s->max_size);
s->state=MSRecorderClosed;
if (s->fd!=-1){
write_wav_header(s->fd, s->rate, s->nchannels, s->size);
close(s->fd);
s->fd=-1;
}
ms_filter_notify_no_arg(f,MS_RECORDER_MAX_SIZE_REACHED);
}
}
}
ms_mutex_unlock(&f->lock);
freemsg(m);
}
}
static void dec_process(MSFilter *f) {
mblk_t *im;
DecState *s=(DecState*)f->data;
while( (im=ms_queue_get(f->inputs[0]))!=0) {
mblk_t *m;
dec_unpacketize(f, s, im, &s->q);
while((m=ms_queue_get(&s->q))!=NULL){
vpx_codec_err_t err;
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
err = vpx_codec_decode(&s->codec, m->b_rptr, m->b_wptr - m->b_rptr, NULL, 0);
if (err) {
ms_warning("vpx_codec_decode failed : %d %s (%s)\n", err, vpx_codec_err_to_string(err), vpx_codec_error_detail(&s->codec));
if ((f->ticker->time - s->last_error_reported_time)>5000 || s->last_error_reported_time==0) {
s->last_error_reported_time=f->ticker->time;
ms_filter_notify_no_arg(f,MS_VIDEO_DECODER_DECODING_ERRORS);
}
if (s->first_image_decoded == FALSE) {
/* if no frames have been decoded yet, do not try to browse decoded frames */
freemsg(m);
continue;
}
}
/* browse decoded frames */
while((img = vpx_codec_get_frame(&s->codec, &iter))) {
int i,j;
if (s->yuv_width != img->d_w || s->yuv_height != img->d_h) {
if (s->yuv_msg)
freemsg(s->yuv_msg);
s->yuv_msg = ms_yuv_buf_alloc(&s->outbuf, img->d_w, img->d_h);
s->yuv_width = img->d_w;
s->yuv_height = img->d_h;
}
/* scale/copy frame to destination mblk_t */
for(i=0; i<3; i++) {
uint8_t* dest = s->outbuf.planes[i];
uint8_t* src = img->planes[i];
int h = img->d_h >> ((i>0)?1:0);
for(j=0; j<h; j++) {
memcpy(dest, src, s->outbuf.strides[i]);
dest += s->outbuf.strides[i];
src += img->stride[i];
}
}
ms_queue_put(f->outputs[0], dupmsg(s->yuv_msg));
if (ms_video_update_average_fps(&s->fps, f->ticker->time)) {
ms_message("VP8 decoder: Frame size: %dx%d", s->yuv_width, s->yuv_height);
}
if (!s->first_image_decoded) {
s->first_image_decoded = TRUE;
ms_filter_notify_no_arg(f,MS_VIDEO_DECODER_FIRST_IMAGE_DECODED);
}
}
freemsg(m);
}
}
}
static void dec_process(MSFilter *f){
DecData *d=(DecData*)f->data;
MSPicture pic = {0};
mblk_t *im,*om = NULL;
ssize_t oBufidx = -1;
size_t bufsize;
bool_t need_reinit=FALSE;
bool_t request_pli=FALSE;
MSQueue nalus;
AMediaCodecBufferInfo info;
ms_queue_init(&nalus);
while((im=ms_queue_get(f->inputs[0]))!=NULL){
if (d->packet_num==0 && d->sps && d->pps){
mblk_set_timestamp_info(d->sps,mblk_get_timestamp_info(im));
mblk_set_timestamp_info(d->pps,mblk_get_timestamp_info(im));
rfc3984_unpack(&d->unpacker, d->sps, &nalus);
rfc3984_unpack(&d->unpacker, d->pps, &nalus);
d->sps=NULL;
d->pps=NULL;
}
if(rfc3984_unpack(&d->unpacker,im,&nalus) <0){
request_pli=TRUE;
}
if (!ms_queue_empty(&nalus)){
int size;
uint8_t *buf=NULL;
ssize_t iBufidx;
size=nalusToFrame(d,&nalus,&need_reinit);
if (need_reinit) {
//In case of rotation, the decoder needs to flushed in order to restart with the new video size
AMediaCodec_flush(d->codec);
d->first_buffer_queued = FALSE;
}
/*First put our H264 bitstream into the decoder*/
iBufidx = AMediaCodec_dequeueInputBuffer(d->codec, TIMEOUT_US);
if (iBufidx >= 0) {
buf = AMediaCodec_getInputBuffer(d->codec, iBufidx, &bufsize);
if(buf == NULL) {
ms_error("MSMediaCodecH264Dec: AMediaCodec_getInputBuffer() returned NULL");
break;
}
if((size_t)size > bufsize) {
ms_error("Cannot copy the bitstream into the input buffer size : %i and bufsize %i",size,(int) bufsize);
break;
} else {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
memcpy(buf,d->bitstream,(size_t)size);
AMediaCodec_queueInputBuffer(d->codec, iBufidx, 0, (size_t)size, (ts.tv_nsec/1000) + 10000LL, 0);
d->first_buffer_queued = TRUE;
}
}else if (iBufidx == AMEDIA_ERROR_UNKNOWN){
ms_error("MSMediaCodecH264Dec: AMediaCodec_dequeueInputBuffer() had an exception");
}
}
d->packet_num++;
if (d->sps && d->pps) request_pli = FALSE;
else request_pli = TRUE;
}
/*secondly try to get decoded frames from the decoder, this is performed every tick*/
while (d->first_buffer_queued && (oBufidx = AMediaCodec_dequeueOutputBuffer(d->codec, &info, TIMEOUT_US)) >= 0){
AMediaFormat *format;
int width = 0, height = 0, color = 0;
uint8_t *buf = AMediaCodec_getOutputBuffer(d->codec, oBufidx, &bufsize);
if(buf == NULL){
ms_filter_notify_no_arg(f,MS_VIDEO_DECODER_DECODING_ERRORS);
ms_error("MSMediaCodecH264Dec: AMediaCodec_getOutputBuffer() returned NULL");
}
format = AMediaCodec_getOutputFormat(d->codec);
if(format != NULL){
AMediaFormat_getInt32(format, "width", &width);
AMediaFormat_getInt32(format, "height", &height);
AMediaFormat_getInt32(format, "color-format", &color);
d->vsize.width=width;
d->vsize.height=height;
AMediaFormat_delete(format);
}
if(buf != NULL && d->sps && d->pps){ /*some decoders output garbage while no sps or pps have been received yet !*/
if(width != 0 && height != 0 ){
if(color == 19) {
//YUV
int ysize = width*height;
int usize = ysize/4;
om = ms_yuv_buf_allocator_get(d->buf_allocator,&pic,width,height);
memcpy(pic.planes[0],buf,ysize);
memcpy(pic.planes[1],buf+ysize,usize);
memcpy(pic.planes[2],buf+ysize+usize,usize);
} else {
uint8_t* cbcr_src = (uint8_t*) (buf + width * height);
om = copy_ycbcrbiplanar_to_true_yuv_with_rotation_and_down_scale_by_2(d->buf_allocator, buf, cbcr_src, 0, width, height, width, width, TRUE, FALSE);
}
if (!d->first_image_decoded) {
ms_message("First frame decoded %ix%i",width,height);
d->first_image_decoded = true;
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_FIRST_IMAGE_DECODED);
}
ms_queue_put(f->outputs[0], om);
}else{
ms_error("MSMediaCodecH264Dec: width and height are not known !");
}
}
AMediaCodec_releaseOutputBuffer(d->codec, oBufidx, FALSE);
}
if (oBufidx == AMEDIA_ERROR_UNKNOWN){
ms_error("MSMediaCodecH264Dec: AMediaCodec_dequeueOutputBuffer() had an exception");
}
if (d->avpf_enabled && request_pli) {
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_SEND_PLI);
}
ms_queue_flush(f->inputs[0]);
}
static void dec_process(MSFilter *f) {
DecState *s = (DecState *)f->data;
mblk_t *im;
vpx_codec_err_t err;
vpx_image_t *img;
vpx_codec_iter_t iter = NULL;
MSQueue frame;
MSQueue mtofree_queue;
Vp8RtpFmtFrameInfo frame_info;
if (!s->ready){
ms_queue_flush(f->inputs[0]);
return;
}
ms_filter_lock(f);
ms_queue_init(&frame);
ms_queue_init(&mtofree_queue);
/* Unpack RTP payload format for VP8. */
vp8rtpfmt_unpacker_feed(&s->unpacker, f->inputs[0]);
/* Decode unpacked VP8 frames. */
while (vp8rtpfmt_unpacker_get_frame(&s->unpacker, &frame, &frame_info) == 0) {
while ((im = ms_queue_get(&frame)) != NULL) {
err = vpx_codec_decode(&s->codec, im->b_rptr, (unsigned int)(im->b_wptr - im->b_rptr), NULL, 0);
if ((s->flags & VPX_CODEC_USE_INPUT_FRAGMENTS) && mblk_get_marker_info(im)) {
err = vpx_codec_decode(&s->codec, NULL, 0, NULL, 0);
}
if (err) {
ms_warning("vp8 decode failed : %d %s (%s)\n", err, vpx_codec_err_to_string(err), vpx_codec_error_detail(&s->codec)?vpx_codec_error_detail(&s->codec):"no details");
}
ms_queue_put(&mtofree_queue, im);
}
/* Get decoded frame */
if ((img = vpx_codec_get_frame(&s->codec, &iter))) {
int i, j;
int reference_updates = 0;
if (vpx_codec_control(&s->codec, VP8D_GET_LAST_REF_UPDATES, &reference_updates) == 0) {
if (frame_info.pictureid_present && ((reference_updates & VP8_GOLD_FRAME) || (reference_updates & VP8_ALTR_FRAME))) {
vp8rtpfmt_send_rpsi(&s->unpacker, frame_info.pictureid);
}
}
if (s->yuv_width != img->d_w || s->yuv_height != img->d_h) {
if (s->yuv_msg) freemsg(s->yuv_msg);
s->yuv_msg = ms_yuv_buf_alloc(&s->outbuf, img->d_w, img->d_h);
ms_message("MSVp8Dec: video is %ix%i", img->d_w, img->d_h);
s->yuv_width = img->d_w;
s->yuv_height = img->d_h;
ms_filter_notify_no_arg(f, MS_FILTER_OUTPUT_FMT_CHANGED);
}
/* scale/copy frame to destination mblk_t */
for (i = 0; i < 3; i++) {
uint8_t *dest = s->outbuf.planes[i];
uint8_t *src = img->planes[i];
int h = img->d_h >> ((i > 0) ? 1 : 0);
for (j = 0; j < h; j++) {
memcpy(dest, src, s->outbuf.strides[i]);
dest += s->outbuf.strides[i];
src += img->stride[i];
}
}
ms_queue_put(f->outputs[0], dupmsg(s->yuv_msg));
ms_average_fps_update(&s->fps, (uint32_t)f->ticker->time);
if (!s->first_image_decoded) {
s->first_image_decoded = TRUE;
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_FIRST_IMAGE_DECODED);
}
}
while ((im = ms_queue_get(&mtofree_queue)) != NULL) {
freemsg(im);
}
}
void MSOpenH264Decoder::feed()
{
if (!isInitialized()) {
ms_error("MSOpenH264Decoder::feed(): not initialized");
ms_queue_flush(mFilter->inputs[0]);
return;
}
MSQueue nalus;
ms_queue_init(&nalus);
mblk_t *im;
while ((im = ms_queue_get(mFilter->inputs[0])) != NULL) {
if ((getIDRPicId() == 0) && (mSPS != 0) && (mPPS != 0)) {
// Push the sps/pps given in sprop-parameter-sets if any
mblk_set_timestamp_info(mSPS, mblk_get_timestamp_info(im));
mblk_set_timestamp_info(mPPS, mblk_get_timestamp_info(im));
rfc3984_unpack(mUnpacker, mSPS, &nalus);
rfc3984_unpack(mUnpacker, mPPS, &nalus);
mSPS = 0;
mPPS = 0;
}
rfc3984_unpack(mUnpacker, im, &nalus);
if (!ms_queue_empty(&nalus)) {
void * pData[3] = { 0 };
SBufferInfo sDstBufInfo = { 0 };
int len = nalusToFrame(&nalus);
DECODING_STATE state = mDecoder->DecodeFrame2(mBitstream, len, (uint8_t**)pData, &sDstBufInfo);
if (state != dsErrorFree) {
ms_error("OpenH264 decoder: DecodeFrame2 failed: 0x%x", state);
if (((mFilter->ticker->time - mLastErrorReportTime) > 5000) || (mLastErrorReportTime == 0)) {
mLastErrorReportTime = mFilter->ticker->time;
ms_filter_notify_no_arg(mFilter, MS_VIDEO_DECODER_DECODING_ERRORS);
}
}
if (sDstBufInfo.iBufferStatus == 1) {
uint8_t * pDst[3] = { 0 };
pDst[0] = (uint8_t *)pData[0];
pDst[1] = (uint8_t *)pData[1];
pDst[2] = (uint8_t *)pData[2];
// Update video size and (re)allocate YUV buffer if needed
if ((mWidth != sDstBufInfo.UsrData.sSystemBuffer.iWidth)
|| (mHeight != sDstBufInfo.UsrData.sSystemBuffer.iHeight)) {
if (mYUVMsg) {
freemsg(mYUVMsg);
}
mWidth = sDstBufInfo.UsrData.sSystemBuffer.iWidth;
mHeight = sDstBufInfo.UsrData.sSystemBuffer.iHeight;
mYUVMsg = ms_yuv_buf_alloc(&mOutbuf, mWidth, mHeight);
ms_filter_notify_no_arg(mFilter,MS_FILTER_OUTPUT_FMT_CHANGED);
}
// Scale/copy frame to destination mblk_t
for (int i = 0; i < 3; i++) {
uint8_t *dst = mOutbuf.planes[i];
uint8_t *src = pDst[i];
int h = mHeight >> (( i > 0) ? 1 : 0);
for(int j = 0; j < h; j++) {
memcpy(dst, src, mOutbuf.strides[i]);
dst += mOutbuf.strides[i];
src += sDstBufInfo.UsrData.sSystemBuffer.iStride[(i == 0) ? 0 : 1];
}
}
ms_queue_put(mFilter->outputs[0], dupmsg(mYUVMsg));
// Update average FPS
if (ms_average_fps_update(&mFPS, mFilter->ticker->time)) {
ms_message("OpenH264 decoder: Frame size: %dx%d", mWidth, mHeight);
}
// Notify first decoded image
if (!mFirstImageDecoded) {
mFirstImageDecoded = true;
ms_filter_notify_no_arg(mFilter, MS_VIDEO_DECODER_FIRST_IMAGE_DECODED);
}
#if MSOPENH264_DEBUG
ms_message("OpenH264 decoder: IDR pic id: %d, Frame num: %d, Temporal id: %d, VCL NAL: %d", getIDRPicId(), getFrameNum(), getTemporalId(), getVCLNal());
#endif
}
}
static void player_process(MSFilter *f){
PlayerData *d=(PlayerData*)f->data;
int bytes =d->big_buffer * 2*(f->ticker->interval*d->rate*d->nchannels)/1000;;
if (d->big_buffer>1)
{
/* when starting reading a file: prepare more data
so that sound card buffer will never remain empty.
*/
d->stat++;
if (d->stat>3)
{
if (d->stat%(d->big_buffer)!=0)
return;
}
}
if (d->state==STARTED){
unsigned long err;
mblk_t *om=allocb(bytes,0);
if (d->pause_time>0){
err=bytes;
memset(om->b_wptr,0,bytes);
d->pause_time-=f->ticker->interval;
}else{
BOOL res;
err=0;
res = ReadFile(d->fd, om->b_wptr, bytes, &err, NULL) ;
}
if (err>=0){
if (err==bytes){
om->b_wptr+=err;
ms_queue_put(f->outputs[0],om);
}
else if (err>0){
BOOL res;
om->b_wptr+=err;
ms_filter_notify_no_arg(f,MS_FILE_PLAYER_EOF);
SetFilePointer(d->fd, d->hsize, NULL, FILE_BEGIN);
//read_wav_header(d);
/* special value for playing file only once */
if (d->loop_after==-2)
{
player_close(f,NULL);
return;
}
if (d->loop_after>0)
{
d->stat=-1;
d->pause_time=d->loop_after;
}
else
{
bytes=bytes-err;
err=0;
res = ReadFile(d->fd, om->b_wptr, bytes, &err, NULL);
if (err>0){
om->b_wptr+=err;
}
}
ms_queue_put(f->outputs[0],om);
}
else if (err==0){
BOOL res;
ms_filter_notify_no_arg(f,MS_FILE_PLAYER_EOF);
SetFilePointer(d->fd, d->hsize, NULL, FILE_BEGIN);
if (d->loop_after==-2)
{
player_close(f,NULL);
return;
}
if (d->loop_after>0)
{
d->stat=-1;
d->pause_time=d->loop_after;
}
else
{
bytes=bytes-err;
err=0;
res = ReadFile(d->fd, om->b_wptr, bytes, &err, NULL);
if (err>0){
om->b_wptr+=err;
ms_queue_put(f->outputs[0],om);
return;
}
}
freemsg(om);
}else freemsg(om);
}else{
#if !defined(_WIN32_WCE)
ms_warning("Fail to read %i bytes: %s",bytes,strerror(errno));
#else
ms_warning("Fail to read %i bytes: %i",bytes,WSAGetLastError());
#endif
}
}
}
static void h264_dec_process(MSFilter *f) {
VTH264DecCtx *ctx = (VTH264DecCtx *)f->data;
mblk_t *pkt;
mblk_t *nalu;
mblk_t *pixbuf;
MSQueue q_nalus;
MSQueue q_nalus2;
CMBlockBufferRef stream = NULL;
CMSampleBufferRef sample = NULL;
CMSampleTimingInfo timing_info;
MSPicture pixbuf_desc;
OSStatus status;
MSList *parameter_sets = NULL;
bool_t unpacking_failed;
ms_queue_init(&q_nalus);
ms_queue_init(&q_nalus2);
// unpack RTP packet
unpacking_failed = FALSE;
while((pkt = ms_queue_get(f->inputs[0]))) {
unpacking_failed |= (rfc3984_unpack(&ctx->unpacker, pkt, &q_nalus) != 0);
}
if(unpacking_failed) {
ms_error("VideoToolboxDecoder: error while unpacking RTP packets");
goto fail;
}
// Pull out SPSs and PPSs and put them into the filter context if necessary
while((nalu = ms_queue_get(&q_nalus))) {
MSH264NaluType nalu_type = ms_h264_nalu_get_type(nalu);
if(nalu_type == MSH264NaluTypeSPS || nalu_type == MSH264NaluTypePPS) {
parameter_sets = ms_list_append(parameter_sets, nalu);
} else if(ctx->format_desc || parameter_sets) {
ms_queue_put(&q_nalus2, nalu);
} else {
ms_free(nalu);
}
}
if(parameter_sets) {
CMFormatDescriptionRef last_format = ctx->format_desc ? CFRetain(ctx->format_desc) : NULL;
h264_dec_update_format_description(ctx, parameter_sets);
parameter_sets = ms_list_free_with_data(parameter_sets, (void (*)(void *))freemsg);
if(ctx->format_desc == NULL) goto fail;
if(last_format) {
CMVideoDimensions last_vsize = CMVideoFormatDescriptionGetDimensions(last_format);
CMVideoDimensions vsize = CMVideoFormatDescriptionGetDimensions(ctx->format_desc);
if(last_vsize.width != vsize.width || last_vsize.height != vsize.height) {
ms_message("VideoToolboxDecoder: new encoded video size %dx%d -> %dx%d",
(int)last_vsize.width, (int)last_vsize.height, (int)vsize.width, (int)vsize.height);
ms_message("VideoToolboxDecoder: destroying decoding session");
VTDecompressionSessionInvalidate(ctx->session);
CFRelease(ctx->session);
ctx->session = NULL;
}
CFRelease(last_format);
}
}
/* Stops proccessing if no IDR has been received yet */
if(ctx->format_desc == NULL) {
ms_warning("VideoToolboxDecoder: no IDR packet has been received yet");
goto fail;
}
/* Initializes the decoder if it has not be done yet or reconfigure it when
the size of the encoded video change */
if(ctx->session == NULL) {
if(!h264_dec_init_decoder(ctx)) {
ms_error("VideoToolboxDecoder: failed to initialized decoder");
goto fail;
}
}
// Pack all nalus in a VTBlockBuffer
CMBlockBufferCreateEmpty(NULL, 0, kCMBlockBufferAssureMemoryNowFlag, &stream);
while((nalu = ms_queue_get(&q_nalus2))) {
CMBlockBufferRef nalu_block;
size_t nalu_block_size = msgdsize(nalu) + H264_NALU_HEAD_SIZE;
uint32_t nalu_size = htonl(msgdsize(nalu));
CMBlockBufferCreateWithMemoryBlock(NULL, NULL, nalu_block_size, NULL, NULL, 0, nalu_block_size, kCMBlockBufferAssureMemoryNowFlag, &nalu_block);
CMBlockBufferReplaceDataBytes(&nalu_size, nalu_block, 0, H264_NALU_HEAD_SIZE);
CMBlockBufferReplaceDataBytes(nalu->b_rptr, nalu_block, H264_NALU_HEAD_SIZE, msgdsize(nalu));
CMBlockBufferAppendBufferReference(stream, nalu_block, 0, nalu_block_size, 0);
CFRelease(nalu_block);
freemsg(nalu);
}
if(!CMBlockBufferIsEmpty(stream)) {
timing_info.duration = kCMTimeInvalid;
timing_info.presentationTimeStamp = CMTimeMake(f->ticker->time, 1000);
timing_info.decodeTimeStamp = CMTimeMake(f->ticker->time, 1000);
CMSampleBufferCreate(
NULL, stream, TRUE, NULL, NULL,
ctx->format_desc, 1, 1, &timing_info,
0, NULL, &sample);
status = VTDecompressionSessionDecodeFrame(ctx->session, sample, 0, NULL, NULL);
CFRelease(sample);
if(status != noErr) {
CFRelease(stream);
ms_error("VideoToolboxDecoder: error while passing encoded frames to the decoder: %d", status);
if(status == kVTInvalidSessionErr) {
h264_dec_uninit_decoder(ctx);
}
goto fail;
}
}
CFRelease(stream);
goto put_frames_out;
fail:
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_DECODING_ERRORS);
ms_filter_lock(f);
if(ctx->enable_avpf) {
ms_message("VideoToolboxDecoder: sending PLI");
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_SEND_PLI);
}
ms_filter_unlock(f);
put_frames_out:
// Transfer decoded frames in the output queue
ms_mutex_lock(&ctx->mutex);
while((pixbuf = ms_queue_get(&ctx->queue))) {
ms_mutex_unlock(&ctx->mutex);
ms_yuv_buf_init_from_mblk(&pixbuf_desc, pixbuf);
ms_filter_lock(f);
if(pixbuf_desc.w != ctx->vsize.width || pixbuf_desc.h != ctx->vsize.height) {
ctx->vsize = (MSVideoSize){ pixbuf_desc.w , pixbuf_desc.h };
}
ms_average_fps_update(&ctx->fps, (uint32_t)f->ticker->time);
if(ctx->first_image) {
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_FIRST_IMAGE_DECODED);
ctx->first_image = FALSE;
}
ms_filter_unlock(f);
ms_queue_put(f->outputs[0], pixbuf);
ms_mutex_lock(&ctx->mutex);
}
ms_mutex_unlock(&ctx->mutex);
// Cleaning
ms_queue_flush(&q_nalus);
ms_queue_flush(&q_nalus2);
ms_queue_flush(f->inputs[0]);
return;
}
static void dec_process(MSFilter *f){
DecData *d=(DecData*)f->data;
MSPicture pic = {0};
mblk_t *im,*om = NULL;
bool_t need_reinit=FALSE;
bool_t request_pli=FALSE;
MSQueue nalus;
ms_queue_init(&nalus);
while((im=ms_queue_get(f->inputs[0]))!=NULL){
if (d->packet_num==0 && d->sps && d->pps){
mblk_set_timestamp_info(d->sps,mblk_get_timestamp_info(im));
mblk_set_timestamp_info(d->pps,mblk_get_timestamp_info(im));
rfc3984_unpack(&d->unpacker, d->sps, &nalus);
rfc3984_unpack(&d->unpacker, d->pps, &nalus);
d->sps=NULL;
d->pps=NULL;
}
if(rfc3984_unpack(&d->unpacker,im,&nalus) <0){
request_pli=TRUE;
}
if (!ms_queue_empty(&nalus)){
AMediaCodecBufferInfo info;
int size;
int width = 0, height = 0, color = 0;
uint8_t *buf=NULL;
size_t bufsize;
ssize_t iBufidx, oBufidx;
size=nalusToFrame(d,&nalus,&need_reinit);
if (need_reinit) {
//In case of rotation, the decoder needs to flushed in order to restart with the new video size
AMediaCodec_flush(d->codec);
}
iBufidx = AMediaCodec_dequeueInputBuffer(d->codec, TIMEOUT_US);
if (iBufidx >= 0) {
buf = AMediaCodec_getInputBuffer(d->codec, iBufidx, &bufsize);
if(buf == NULL) {
break;
}
if((size_t)size > bufsize) {
ms_error("Cannot copy the bitstream into the input buffer size : %i and bufsize %i",size,(int) bufsize);
} else {
memcpy(buf,d->bitstream,(size_t)size);
AMediaCodec_queueInputBuffer(d->codec, iBufidx, 0, (size_t)size, TIMEOUT_US, 0);
}
}
oBufidx = AMediaCodec_dequeueOutputBuffer(d->codec, &info, TIMEOUT_US);
if(oBufidx >= 0){
AMediaFormat *format;
buf = AMediaCodec_getOutputBuffer(d->codec, oBufidx, &bufsize);
if(buf == NULL){
ms_filter_notify_no_arg(f,MS_VIDEO_DECODER_DECODING_ERRORS);
break;
}
format = AMediaCodec_getOutputFormat(d->codec);
if(format != NULL){
AMediaFormat_getInt32(format, "width", &width);
AMediaFormat_getInt32(format, "height", &height);
AMediaFormat_getInt32(format, "color-format", &color);
d->vsize.width=width;
d->vsize.height=height;
AMediaFormat_delete(format);
}
}
if(buf != NULL){
//YUV
if(width != 0 && height != 0 ){
if(color == 19) {
int ysize = width*height;
int usize = ysize/4;
om=ms_yuv_buf_alloc(&pic,width,height);
memcpy(pic.planes[0],buf,ysize);
memcpy(pic.planes[1],buf+ysize,usize);
memcpy(pic.planes[2],buf+ysize+usize,usize);
} else {
uint8_t* cbcr_src = (uint8_t*) (buf + width * height);
om = copy_ycbcrbiplanar_to_true_yuv_with_rotation_and_down_scale_by_2(d->buf_allocator, buf, cbcr_src, 0, width, height, width, width, TRUE, FALSE);
}
if (!d->first_image_decoded) {
ms_message("First frame decoded %ix%i",width,height);
d->first_image_decoded = true;
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_FIRST_IMAGE_DECODED);
}
ms_queue_put(f->outputs[0], om);
}
if(oBufidx > 0) {
AMediaCodec_releaseOutputBuffer(d->codec, oBufidx, FALSE);
}
}
}
d->packet_num++;
}
if (d->avpf_enabled && request_pli) {
ms_filter_notify_no_arg(f, MS_VIDEO_DECODER_SEND_PLI);
}
}
