/**
* @brief Receive decoded video packet.
*
* @param av Handler.
* @param output Storage.
* @return int
* @retval 0 Success.
* @retval ToxAvError On Error.
*/
inline__ int toxav_recv_video ( ToxAv *av, int32_t call_index, vpx_image_t **output)
{
if ( !output ) return ErrorInternal;
uint8_t packet [RTP_PAYLOAD_SIZE];
int recved_size = 0;
int rc;
CallSpecific *call = &av->calls[call_index];
do {
recved_size = toxav_recv_rtp_payload(av, call_index, TypeVideo, packet);
if (recved_size > 0 && ( rc = vpx_codec_decode(&call->cs->v_decoder, packet, recved_size, NULL, 0) ) != VPX_CODEC_OK) {
/*fprintf(stderr, "Error decoding video: %s\n", vpx_codec_err_to_string(rc));*/
return ErrorInternal;
}
} while (recved_size > 0);
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
*output = img;
return 0;
}
int decompress_image(struct vpx_context *ctx, const uint8_t *in, int size, uint8_t *out[3], int outstride[3])
{
vpx_image_t *img;
int frame_sz = size;
vpx_codec_iter_t iter = NULL;
const uint8_t *frame = in;
int i = 0;
if (vpx_codec_decode(&ctx->codec, frame, frame_sz, NULL, 0)) {
codec_error(&ctx->codec, "vpx_codec_decode");
return -1;
}
img = vpx_codec_get_frame(&ctx->codec, &iter);
if (img == NULL) {
codec_error(&ctx->codec, "vpx_codec_get_frame");
return -1;
}
for (i = 0; i < 3; i++) {
out[i] = img->planes[i];
outstride[i] = img->stride[i];
}
ctx->pixfmt = img->fmt;
return 0;
}
void krad_vpx_decoder_decode (krad_vpx_decoder_t *vpx,
void *buffer,
int len) {
if (vpx_codec_decode (&vpx->decoder, buffer, len, 0, 0)) {
printf ("Failed to decode %d byte frame: %s\n",
len, vpx_codec_error (&vpx->decoder));
}
if (vpx->width == 0) {
vpx_codec_get_stream_info (&vpx->decoder, &vpx->stream_info);
printf ("VPX Stream Info: W:%d H:%d KF:%d\n",
vpx->stream_info.w,
vpx->stream_info.h,
vpx->stream_info.is_kf);
vpx->width = vpx->stream_info.w;
vpx->height = vpx->stream_info.h;
}
vpx->iter = NULL;
vpx->img = vpx_codec_get_frame (&vpx->decoder, &vpx->iter);
}
void krad_vpx_decoder_decode (krad_vpx_decoder_t *kradvpx, void *buffer, int len) {
if (vpx_codec_decode(&kradvpx->decoder, buffer, len, 0, 0))
{
failfast ("Failed to decode %d byte frame: %s\n", len, vpx_codec_error(&kradvpx->decoder));
//exit(1);
}
vpx_codec_get_stream_info (&kradvpx->decoder, &kradvpx->stream_info);
//printf("VPX Stream Info: W:%d H:%d KF:%d\n", kradvpx->stream_info.w, kradvpx->stream_info.h,
// kradvpx->stream_info.is_kf);
if (kradvpx->width == 0) {
kradvpx->width = kradvpx->stream_info.w;
kradvpx->height = kradvpx->stream_info.h;
}
/*
if (kradvpx->img == NULL) {
kradvpx->width = kradvpx->stream_info.w;
kradvpx->height = kradvpx->stream_info.h;
if ((kradvpx->img = vpx_img_alloc(NULL, VPX_IMG_FMT_YV12, kradvpx->stream_info.w,
kradvpx->stream_info.h, 1)) == NULL) {
failfast ("Failed to allocate vpx image\n");
}
}
*/
kradvpx->iter = NULL;
kradvpx->img = vpx_codec_get_frame (&kradvpx->decoder, &kradvpx->iter);
}
/**
* @brief Receive decoded video packet.
*
* @param av Handler.
* @param output Storage.
* @return int
* @retval 0 Success.
* @retval ToxAvError On Error.
*/
inline__ int toxav_recv_video ( ToxAv *av, vpx_image_t **output)
{
if ( !output ) return ErrorInternal;
uint8_t packet [RTP_PAYLOAD_SIZE];
int recved_size = 0;
int error;
do {
recved_size = toxav_recv_rtp_payload(av, TypeVideo, packet);
if (recved_size > 0 && ( error = vpx_codec_decode(&av->cs->v_decoder, packet, recved_size, NULL, 0) ) != VPX_CODEC_OK)
fprintf(stderr, "Error decoding: %s\n", vpx_codec_err_to_string(error));
} while (recved_size > 0);
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
img = vpx_codec_get_frame(&av->cs->v_decoder, &iter);
*output = img;
return 0;
/* Yeah, i set output to be NULL if nothing received
*/
}
EVideoDecoderReadState VideoDecoderVPX::readNextFrame( float & _pts )
{
const mkvparser::Block * block = m_blockEntry->GetBlock();
const int frameCount = block->GetFrameCount();
for (int i = 0; i < frameCount; ++i)
{
const mkvparser::Block::Frame & frame = block->GetFrame( i );
m_frameSize = frame.len;
//const long long offset = frame.pos;
m_frame = (unsigned char *)realloc( m_frame, m_frameSize );
frame.Read( &m_reader, m_frame );
vpx_codec_err_t err_decode = vpx_codec_decode( &m_codec, m_frame, m_frameSize, NULL, 0);
if( err_decode != VPX_CODEC_OK )
{
return VDRS_FAILURE;
}
}
m_track->GetNext( m_blockEntry, m_blockEntry );
m_pts += m_dataInfo.getFrameTiming();
return VDRS_SUCCESS;
}
int main(int argc, char **argv) {
int frame_cnt = 0;
FILE *outfile = NULL;
vpx_codec_ctx_t codec;
VpxVideoReader *reader = NULL;
const VpxVideoInfo *info = NULL;
const VpxInterface *decoder = NULL;
exec_name = argv[0];
if (argc != 3)
die("Invalid number of arguments.");
reader = vpx_video_reader_open(argv[1]);
if (!reader)
die("Failed to open %s for reading.", argv[1]);
if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing.", argv[2]);
info = vpx_video_reader_get_info(reader);
decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc);
if (!decoder)
die("Unknown input codec.");
printf("Using %s\n", vpx_codec_iface_name(decoder->codec_interface()));
if (vpx_codec_dec_init(&codec, decoder->codec_interface(), NULL, 0))
die_codec(&codec, "Failed to initialize decoder");
while (vpx_video_reader_read_frame(reader)) {
vpx_codec_iter_t iter = NULL;
vpx_image_t *img = NULL;
size_t frame_size = 0;
const unsigned char *frame = vpx_video_reader_get_frame(reader,
&frame_size);
if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0))
die_codec(&codec, "Failed to decode frame");
while ((img = vpx_codec_get_frame(&codec, &iter)) != NULL) {
unsigned char digest[16];
get_image_md5(img, digest);
print_md5(outfile, digest);
fprintf(outfile, " img-%dx%d-%04d.i420\n",
img->d_w, img->d_h, ++frame_cnt);
}
}
printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec))
die_codec(&codec, "Failed to destroy codec.");
vpx_video_reader_close(reader);
fclose(outfile);
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
int frame_cnt = 0;
FILE *outfile = NULL;
vpx_codec_ctx_t codec;
VpxVideoReader *reader = NULL;
const VpxInterface *decoder = NULL;
const VpxVideoInfo *info = NULL;
exec_name = argv[0];
if (argc != 3)
die("Invalid number of arguments.");
reader = vpx_video_reader_open(argv[1]);
if (!reader)
die("Failed to open %s for reading.", argv[1]);
if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing.", argv[2]);
info = vpx_video_reader_get_info(reader);
decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc);
if (!decoder)
die("Unknown input codec.");
printf("Using %s\n", vpx_codec_iface_name(decoder->interface()));
if (vpx_codec_dec_init(&codec, decoder->interface(), NULL, 0))
die_codec(&codec, "Failed to initialize decoder.");
while (vpx_video_reader_read_frame(reader)) {
vpx_codec_iter_t iter = NULL;
vpx_image_t *img = NULL;
size_t frame_size = 0;
const unsigned char *frame = vpx_video_reader_get_frame(reader,
&frame_size);
if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0))
die_codec(&codec, "Failed to decode frame.");
while ((img = vpx_codec_get_frame(&codec, &iter)) != NULL) {
vpx_img_write(img, outfile);
++frame_cnt;
}
}
printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec))
die_codec(&codec, "Failed to destroy codec");
printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n",
info->frame_width, info->frame_height, argv[2]);
vpx_video_reader_close(reader);
fclose(outfile);
return EXIT_SUCCESS;
}
int32_t kr_vpx_decode (krad_vpx_decoder_t *vpx,
kr_medium_t *medium,
kr_codeme_t *codeme) {
if (vpx_codec_decode (&vpx->decoder, codeme->data, codeme->sz, 0, 0)) {
printf ("Failed to decode %zu byte frame: %s\n",
codeme->sz, vpx_codec_error (&vpx->decoder));
}
if (vpx->width == 0) {
vpx_codec_get_stream_info (&vpx->decoder, &vpx->stream_info);
printk ("VPX Stream Info: W:%d H:%d KF:%d\n",
vpx->stream_info.w,
vpx->stream_info.h,
vpx->stream_info.is_kf);
vpx->width = vpx->stream_info.w;
vpx->height = vpx->stream_info.h;
}
vpx->iter = NULL;
vpx->img = vpx_codec_get_frame (&vpx->decoder, &vpx->iter);
if (vpx->img != NULL) {
medium->v.pps[0] = vpx->width;
medium->v.pps[1] = vpx->width/2;
medium->v.pps[2] = vpx->width/2;
//printf ("VPXDEC: s %u %u %u", vpx->img->stride[0], vpx->img->stride[1], vpx->img->stride[2]);
//memcpy (medium->data, vpx->img->img_data, vpx->img->stride[0] * vpx->height + (vpx->img->stride[1] * vpx->height * 2));
int r;
for (r = 0; r< vpx->height; r++) {
memcpy (medium->data + (r * vpx->width), vpx->img->planes[0] + (r * vpx->img->stride[0]), vpx->width);
}
for (r = 0; r< vpx->height/2; r++) {
memcpy (medium->data + (vpx->width * (vpx->height)) + (r * vpx->width/2), vpx->img->planes[1] + (r * vpx->img->stride[1]), vpx->width / 2);
}
for (r = 0; r< vpx->height/2; r++) {
memcpy (medium->data + (vpx->width * (vpx->height)) + ((vpx->width * (vpx->height))/4) + (r * vpx->width/2),
vpx->img->planes[2] + (r * vpx->img->stride[2]), vpx->width / 2);
}
//memcpy (medium->data + vpx->img->stride[0] * vpx->height, vpx->img->planes[1], vpx->img->stride[1] * vpx->height / 2);
//memcpy (medium->data + (vpx->img->stride[0] * vpx->height) + (vpx->img->stride[1] * (vpx->height /2)), vpx->img->planes[2], vpx->img->stride[2] * vpx->height / 2);
medium->v.ppx[0] = medium->data;
medium->v.ppx[1] = medium->data + vpx->width * (vpx->height);
medium->v.ppx[2] = medium->data + vpx->width * (vpx->height) + ((vpx->width * (vpx->height)) /4);
return 1;
}
return 0;
}
RefPtr<MediaDataDecoder::DecodePromise>
VPXDecoder::ProcessDecode(MediaRawData* aSample)
{
MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
if (vpx_codec_err_t r = vpx_codec_decode(&mVPX, aSample->Data(), aSample->Size(), nullptr, 0)) {
LOG("VPX Decode error: %s", vpx_codec_err_to_string(r));
return DecodePromise::CreateAndReject(
MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR,
RESULT_DETAIL("VPX error: %s", vpx_codec_err_to_string(r))),
__func__);
}
vpx_codec_iter_t iter = nullptr;
vpx_image_t *img;
vpx_image_t *img_alpha = nullptr;
bool alpha_decoded = false;
DecodedData results;
while ((img = vpx_codec_get_frame(&mVPX, &iter))) {
NS_ASSERTION(img->fmt == VPX_IMG_FMT_I420 ||
img->fmt == VPX_IMG_FMT_I444,
"WebM image format not I420 or I444");
NS_ASSERTION(!alpha_decoded,
"Multiple frames per packet that contains alpha");
if (aSample->AlphaSize() > 0) {
if (!alpha_decoded){
MediaResult rv = DecodeAlpha(&img_alpha, aSample);
if (NS_FAILED(rv)) {
return DecodePromise::CreateAndReject(rv, __func__);
}
alpha_decoded = true;
}
}
// Chroma shifts are rounded down as per the decoding examples in the SDK
VideoData::YCbCrBuffer b;
b.mPlanes[0].mData = img->planes[0];
b.mPlanes[0].mStride = img->stride[0];
b.mPlanes[0].mHeight = img->d_h;
b.mPlanes[0].mWidth = img->d_w;
b.mPlanes[0].mOffset = b.mPlanes[0].mSkip = 0;
b.mPlanes[1].mData = img->planes[1];
b.mPlanes[1].mStride = img->stride[1];
b.mPlanes[1].mOffset = b.mPlanes[1].mSkip = 0;
b.mPlanes[2].mData = img->planes[2];
b.mPlanes[2].mStride = img->stride[2];
b.mPlanes[2].mOffset = b.mPlanes[2].mSkip = 0;
if (img->fmt == VPX_IMG_FMT_I420) {
b.mPlanes[1].mHeight = (img->d_h + 1) >> img->y_chroma_shift;
b.mPlanes[1].mWidth = (img->d_w + 1) >> img->x_chroma_shift;
b.mPlanes[2].mHeight = (img->d_h + 1) >> img->y_chroma_shift;
b.mPlanes[2].mWidth = (img->d_w + 1) >> img->x_chroma_shift;
} else if (img->fmt == VPX_IMG_FMT_I444) {
static int encode_frame(vpx_codec_ctx_t *ecodec,
vpx_codec_enc_cfg_t *cfg,
vpx_image_t *img,
unsigned int frame_in,
VpxVideoWriter *writer,
int test_decode,
vpx_codec_ctx_t *dcodec,
unsigned int *frame_out,
int *mismatch_seen) {
int got_pkts = 0;
vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt = NULL;
int got_data;
const vpx_codec_err_t res = vpx_codec_encode(ecodec, img, frame_in, 1,
0, VPX_DL_GOOD_QUALITY);
if (res != VPX_CODEC_OK)
die_codec(ecodec, "Failed to encode frame");
got_data = 0;
while ((pkt = vpx_codec_get_cx_data(ecodec, &iter)) != NULL) {
got_pkts = 1;
if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
if (!(pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT)) {
*frame_out += 1;
}
if (!vpx_video_writer_write_frame(writer,
pkt->data.frame.buf,
pkt->data.frame.sz,
pkt->data.frame.pts)) {
die_codec(ecodec, "Failed to write compressed frame");
}
printf(keyframe ? "K" : ".");
fflush(stdout);
got_data = 1;
// Decode 1 frame.
if (test_decode) {
if (vpx_codec_decode(dcodec, pkt->data.frame.buf,
(unsigned int)pkt->data.frame.sz, NULL, 0))
die_codec(dcodec, "Failed to decode frame.");
}
}
}
// Mismatch checking
if (got_data && test_decode) {
testing_decode(ecodec, dcodec, cfg, *frame_out, mismatch_seen);
}
return got_pkts;
}
void vc_iterate(VCSession *vc)
{
if (!vc) {
return;
}
pthread_mutex_lock(vc->queue_mutex);
struct RTPMessage *p;
if (!rb_read(vc->vbuf_raw, (void **)&p)) {
LOGGER_TRACE(vc->log, "no Video frame data available");
pthread_mutex_unlock(vc->queue_mutex);
return;
}
pthread_mutex_unlock(vc->queue_mutex);
const struct RTPHeader *const header = &p->header;
uint32_t full_data_len;
if (header->flags & RTP_LARGE_FRAME) {
full_data_len = header->data_length_full;
LOGGER_DEBUG(vc->log, "vc_iterate:001:full_data_len=%d", (int)full_data_len);
} else {
full_data_len = p->len;
LOGGER_DEBUG(vc->log, "vc_iterate:002");
}
LOGGER_DEBUG(vc->log, "vc_iterate: rb_read p->len=%d p->header.xe=%d", (int)full_data_len, p->header.xe);
LOGGER_DEBUG(vc->log, "vc_iterate: rb_read rb size=%d", (int)rb_size(vc->vbuf_raw));
const vpx_codec_err_t rc = vpx_codec_decode(vc->decoder, p->data, full_data_len, nullptr, MAX_DECODE_TIME_US);
free(p);
if (rc != VPX_CODEC_OK) {
LOGGER_ERROR(vc->log, "Error decoding video: %d %s", (int)rc, vpx_codec_err_to_string(rc));
return;
}
/* Play decoded images */
vpx_codec_iter_t iter = nullptr;
for (vpx_image_t *dest = vpx_codec_get_frame(vc->decoder, &iter);
dest != nullptr;
dest = vpx_codec_get_frame(vc->decoder, &iter)) {
if (vc->vcb) {
vc->vcb(vc->av, vc->friend_number, dest->d_w, dest->d_h,
(const uint8_t *)dest->planes[0], (const uint8_t *)dest->planes[1], (const uint8_t *)dest->planes[2],
dest->stride[0], dest->stride[1], dest->stride[2], vc->vcb_user_data);
}
vpx_img_free(dest); // is this needed? none of the VPx examples show that
}
}
JNIEXPORT jint Java_ryulib_VideoZip_VPX_DecodeBitmap(JNIEnv* env,
jclass clazz, jint handle, jobject bitmap, jbyteArray buffer, jint bufferSize)
{
int result = 0;
RyuVPX *pHandle = (RyuVPX *) handle;
jbyte *pByteBuffer = (*env)->GetByteArrayElements(env, buffer, 0);
unsigned char *pFrame = (unsigned char *) pByteBuffer;
int *pFrameSize;
int frameSize = 0;
int count = 0;
vpx_image_t *img;
vpx_codec_iter_t iter;
while (count < bufferSize) {
pFrameSize = (int *) pFrame;
frameSize = *pFrameSize;
pFrame = pFrame + sizeof(int);
if (vpx_codec_decode(&pHandle->codec, (unsigned char*) pFrame, frameSize, NULL, 0)) {
goto EXIT;
}
pFrame = pFrame + frameSize;
count = count + sizeof(int) + frameSize;
iter = NULL;
while((img = vpx_codec_get_frame(&pHandle->codec, &iter))) {
void *pixelBitmap;
if (AndroidBitmap_lockPixels(env, bitmap, &pixelBitmap) >= 0) {
I420ToARGB(
(unsigned char *) img->planes[0], img->stride[0],
(unsigned char *) img->planes[1], img->stride[1],
(unsigned char *) img->planes[2], img->stride[2],
(unsigned char *) pixelBitmap,
img->d_w * _PixelSize,
img->d_w, img->d_h
);
AndroidBitmap_unlockPixels(env, bitmap);
}
result = 1;
}
}
EXIT:
(*env)->ReleaseByteArrayElements(env, buffer, pByteBuffer, 0);
return result;
}
// Decodes any frame that was parsed by FFmpeg
static int
vpx_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
{
Decoder * const decoder = avctx->opaque;
AVFrame * const frame = data;
const void *iter;
struct vpx_image *img;
vpx_codec_err_t err;
int i;
err = vpx_codec_decode(&decoder->decoder, pkt->data, pkt->size, NULL, 0);
if (err != VPX_CODEC_OK)
goto error_decode;
iter = NULL;
img = vpx_codec_get_frame(&decoder->decoder, &iter);
if (img) {
frame->format = ff_get_pix_fmt(img->fmt);
if (frame->format == AV_PIX_FMT_NONE || frame->format != avctx->pix_fmt)
goto error_unsupported_format;
frame->width = img->d_w;
frame->height = img->d_h;
if (frame->width != avctx->width || frame->height != avctx->height) {
avcodec_set_dimensions(avctx, frame->width, frame->height);
if (frame->width != avctx->width || frame->height != avctx->height)
goto error_size_change;
}
frame->interlaced_frame = 0;
for (i = 0; i < 4; i++) {
frame->data[i] = img->planes[i];
frame->linesize[i] = img->stride[i];
}
*got_frame = 1;
}
return pkt->size;
/* ERRORS */
error_decode:
mvt_error("failed to decode frame: %s", vpx_codec_error(&decoder->decoder));
return AVERROR_INVALIDDATA;
error_unsupported_format:
mvt_error("unsupported image format (%d)", img->fmt);
return AVERROR_INVALIDDATA;
error_size_change:
mvt_error("failed to change dimensions (%dx%d)",
frame->width, frame->height);
return AVERROR_INVALIDDATA;
}
void VPXDecoder::decodeFrame(Graphics::Surface &surface, Common::SeekableReadStream &dataStream) {
if (!_initialized)
return;
// Read all the data from the stream
Common::ScopedArray<byte> data(new byte[dataStream.size()]);
dataStream.read(data.get(), dataStream.size());
// Perform the actual decode
vpx_codec_err_t result = vpx_codec_decode(&_context, data.get(), dataStream.size(), 0, 0);
if (result != VPX_CODEC_OK)
return;
// Try to get the image
vpx_codec_iter_t iter = 0;
vpx_image_t *image = vpx_codec_get_frame(&_context, &iter);
if (!image)
return;
// Figure out the color range
Graphics::YUVToRGBManager::LuminanceScale scale;
switch (image->range) {
case VPX_CR_STUDIO_RANGE:
scale = Graphics::YUVToRGBManager::kScaleITU;
break;
case VPX_CR_FULL_RANGE:
scale = Graphics::YUVToRGBManager::kScaleFull;
break;
default:
return;
}
// If we don't have it already, create our local surface
if (!_surface)
_surface.reset(new Graphics::Surface(image->w, image->h));
// Do the conversion based on the color space
switch (image->fmt) {
case VPX_IMG_FMT_I420:
YUVToRGBMan.convert420(scale, _surface->getData(), _surface->getPitch(), image->planes[0], image->planes[1], image->planes[2], image->w, image->h, image->stride[0], image->stride[1]);
break;
default:
return;
}
// Copy the subarea into the surface
for (int y = 0; y < surface.getHeight(); y++)
memcpy(surface.getData() + y * surface.getPitch(), _surface->getData() + (y * image->d_h) * image->d_w * 4, image->d_w * 4);
}
static int
x_vpx_decoder_decode(vpx_dec_ctx_t *_decoder, const char *buffer, size_t bufsiz)
{
vpx_image_t *img;
unsigned char *buf;
vpx_codec_iter_t iter = NULL;
vpx_codec_decode(_decoder, buffer, bufsiz, 0, VPX_DL_REALTIME);
while ((img = vpx_codec_get_frame(_decoder, &iter)))
{
printf("Decoded frame(fmt(%d)) bps=%d,%dx%d\n", img->fmt, img->bps,
img->d_w, img->d_h);
// img->img_data;
}
return 0;
}
int
__decode_vp8_pkt(vpx_codec_ctx_t *_decoder, const uint8_t *buffer,
unsigned int bufsiz, int outfd)
{
vpx_image_t *img;
vpx_codec_iter_t iter = NULL;
vpx_codec_decode(_decoder, buffer, bufsiz, 0, VPX_DL_REALTIME);
while ((img = vpx_codec_get_frame(_decoder, &iter)))
{
// printf("Decoded frame(fmt(0x%x)) bps=%d,%dx%d\n", img->fmt, img->bps,
// img->d_w, img->d_h);
x_vp8_write_frame(outfd, img);
}
return 0;
}
static void decode_video(ToxAv *av, CallSpecific *call, DECODE_PACKET *p)
{
int32_t call_index = call - av->calls;
int rc = vpx_codec_decode(&call->cs->v_decoder, p->data, p->size, NULL, MAX_DECODE_TIME_US);
if (rc != VPX_CODEC_OK) {
LOGGER_ERROR("Error decoding video: %s\n", vpx_codec_err_to_string(rc));
}
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
if (img && av->video_callback) {
av->video_callback(av, call_index, img, av->video_callback_userdata);
} else {
LOGGER_WARNING("Video packet dropped due to missing callback or no image!");
}
free(p);
}
/*
* Method: codec_decode
*/
JNIEXPORT jint JNICALL
Java_org_jitsi_impl_neomedia_codec_video_VPX_codec_1decode
(JNIEnv *env,
jclass clazz,
jlong context,
jbyteArray buf,
jint buf_offset,
jint buf_size,
jlong user_priv,
jlong deadline)
{
jbyte *buf_ptr = (*env)->GetByteArrayElements(env, buf, NULL);
vpx_codec_err_t ret;
ret = vpx_codec_decode((vpx_codec_ctx_t *) (intptr_t) context,
(uint8_t *) (buf_ptr + buf_offset),
(unsigned int) buf_size,
(void *) (intptr_t) user_priv,
(long) deadline);
(*env)->ReleaseByteArrayElements(env, buf, buf_ptr, JNI_ABORT);
return (jint) ret;
}
/*
Decode the given data. Note that on linux libvpx
will crash at this moment when the first partition
you pass into this function is not a key frame.
*/
int rxs_decoder_decode(rxs_decoder* dec, uint8_t* buffer, uint32_t nbytes) {
vpx_codec_iter_t iter = NULL;
vpx_codec_err_t err;
if (!dec) { return -1; }
if (!buffer) { return -2; }
if (!nbytes) { return -3; }
dec->img = NULL;
err = vpx_codec_decode(&dec->ctx, buffer, nbytes, NULL, 0);
if (err) {
printf("Error: cannot decode buffer: %s\n", vpx_codec_err_to_string(err));
return -4;
}
while ( (dec->img = vpx_codec_get_frame(&dec->ctx, &iter)) ) {
dec->on_image(dec, dec->img);
}
return 0;
}
/**
\fn uncompress
*/
bool decoderVPX::uncompress (ADMCompressedImage * in, ADMImage * out)
{
if (vpx_codec_decode(VPX, in->data, in->dataLength, NULL, 0) != VPX_CODEC_OK)
{
ADM_warning("Error decoding VPX\n");
return false;
}
struct vpx_image *img;
const void *iter = NULL;
img = vpx_codec_get_frame(VPX, &iter);
if(img)
{
if (img->fmt != VPX_IMG_FMT_I420)
{
ADM_warning("Wrong Colorspace\n");
return false;
}
ADMImageRef *r=out->castToRef();
if(r)
{
r->_planes[0]=img->planes[0];
r->_planes[1]=img->planes[1];
r->_planes[2]=img->planes[2];
r->_planeStride[0]=img->stride[0];
r->_planeStride[1]=img->stride[1];
r->_planeStride[2]=img->stride[2];
r->_colorspace=ADM_COLOR_YV12;
r->Pts=in->demuxerPts;
r->flags=in->flags;
return true;
}
ADM_warning("Only ref for VPX decoder\n");
}
return false;
}
uint8_t stream_parse_yuv(Stream *stream, uint8_t *gl_luma_buf, uint8_t *gl_chromaB_buf, uint8_t *gl_chromaR_buf, size_t *net_bytes_read) {
*net_bytes_read = 0;
if (vpx_video_stream_reader_read_frame(stream->net_buf, stream->net_buf_fill, stream->reader)) {
size_t frame_size = 0;
const unsigned char *frame = vpx_video_stream_reader_get_frame(stream->reader, &frame_size);
*net_bytes_read = frame_size + 12;
if (vpx_codec_decode(&stream->codec, frame, (unsigned int)frame_size, NULL, 16000))
proc_warn("Failed to decode frame");
vpx_image_t *img = NULL;
stream->iter = NULL;
while ((img = vpx_codec_get_frame(&stream->codec, &stream->iter)) != NULL) {
size_t y;
for (y = 0; y < img->d_h; y++) {
memcpy(gl_luma_buf + y * img->d_w, img->planes[0] + y * img->stride[0], img->d_w);
memcpy(gl_chromaB_buf + y/2 * img->d_w/2, img->planes[1] + y/2 * img->stride[1], img->d_w/2);
memcpy(gl_chromaR_buf + y/2 * img->d_w/2, img->planes[2] + y/2 * img->stride[2], img->d_w/2);
}
return 0;
}
}
return 1;
}
uint8_t stream_parse(Stream *stream, uint8_t *gl_rgb_buf, size_t *net_bytes_read) {
*net_bytes_read = 0;
if (vpx_video_stream_reader_read_frame(stream->net_buf, stream->net_buf_fill, stream->reader)) {
size_t frame_size = 0;
const unsigned char *frame = vpx_video_stream_reader_get_frame(stream->reader, &frame_size);
*net_bytes_read = frame_size + 12;
if (vpx_codec_decode(&stream->codec, frame, (unsigned int)frame_size, NULL, 0))
proc_warn("Failed to decode frame");
vpx_image_t *img = NULL;
stream->iter = NULL;
while ((img = vpx_codec_get_frame(&stream->codec, &stream->iter)) != NULL) {
int status = ConvertFromI420(img->planes[0], img->stride[0],
img->planes[2], img->stride[2],
img->planes[1], img->stride[1],
gl_rgb_buf, img->d_w * 3,
img->d_w, img->d_h,
FOURCC_24BG);
// proc_info("I420ToRGB24 to status - %i", status);
return 0;
}
}
return 1;
}
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);
}
}
}
Dynamic read_frame(struct DecInputContext *input) {
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
uint8_t *buf = NULL;
size_t bytes_in_buffer = 0;
size_t buffer_size = 0;
int status = webm_read_frame(input->webm_ctx, &buf, &bytes_in_buffer, &buffer_size);
if(status == 0) {
if(vpx_codec_decode(input->decoder, buf, (unsigned int)bytes_in_buffer, NULL, 0)) {
warn("Failed to decode frame: %s", vpx_codec_error(input->decoder));
}
} else {
warn("EOF/Error %d", status);
}
if(status == 0) {
img = vpx_codec_get_frame(input->decoder, &iter);
} else {
img = NULL;
}
/*
{
status:Int, (0 = success, 1 = EOF, -1 = Error)
data:BytesData, // image bytes
width:Int,
height:Int,
comp:Int, // RGBA = 4
}
*/
int width = 0;
int height = 0;
int comp = 4;
unsigned char* rgba;
hx::Anon result = hx::Anon_obj::Create();
result->Add(HX_CSTRING("status"), status);
if(img != NULL) {
width = img->d_w;
height = img->d_h;
rgba = (unsigned char*)malloc(sizeof(unsigned char) * width * height * comp);
if(img->fmt == VPX_IMG_FMT_I420) {
::libyuv::I420ToABGR(
img->planes[VPX_PLANE_Y],img->stride[VPX_PLANE_Y],
img->planes[VPX_PLANE_U],img->stride[VPX_PLANE_U],
img->planes[VPX_PLANE_V],img->stride[VPX_PLANE_V],
rgba, width * comp, width, height
);
ImgBytesData data = to_haxe_bytes(rgba, width * height * comp);
result->Add(HX_CSTRING("data"), data);
} else {
warn("Img format unknown");
}
} else {
warn("No image decoded!");
}
result->Add(HX_CSTRING("width"), width);
result->Add(HX_CSTRING("height"), height);
result->Add(HX_CSTRING("comp"), comp);
return result;
}
int main(int argc, char **argv) {
int frame_cnt = 0;
FILE *outfile = NULL;
vpx_codec_ctx_t codec;
const VpxInterface *decoder = NULL;
VpxVideoReader *reader = NULL;
const VpxVideoInfo *info = NULL;
int n = 0;
int m = 0;
int is_range = 0;
char *nptr = NULL;
exec_name = argv[0];
if (argc != 4)
die("Invalid number of arguments.");
reader = vpx_video_reader_open(argv[1]);
if (!reader)
die("Failed to open %s for reading.", argv[1]);
if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing.", argv[2]);
n = strtol(argv[3], &nptr, 0);
m = strtol(nptr + 1, NULL, 0);
is_range = (*nptr == '-');
if (!n || !m || (*nptr != '-' && *nptr != '/'))
die("Couldn't parse pattern %s.\n", argv[3]);
info = vpx_video_reader_get_info(reader);
decoder = get_vpx_decoder_by_fourcc(info->codec_fourcc);
if (!decoder)
die("Unknown input codec.");
printf("Using %s\n", vpx_codec_iface_name(decoder->interface()));
if (vpx_codec_dec_init(&codec, decoder->interface(), NULL, 0))
die_codec(&codec, "Failed to initialize decoder.");
while (vpx_video_reader_read_frame(reader)) {
vpx_codec_iter_t iter = NULL;
vpx_image_t *img = NULL;
size_t frame_size = 0;
int skip;
const unsigned char *frame = vpx_video_reader_get_frame(reader,
&frame_size);
if (vpx_codec_decode(&codec, frame, (unsigned int)frame_size, NULL, 0))
die_codec(&codec, "Failed to decode frame.");
++frame_cnt;
skip = (is_range && frame_cnt >= n && frame_cnt <= m) ||
(!is_range && m - (frame_cnt - 1) % m <= n);
if (!skip) {
putc('.', stdout);
while ((img = vpx_codec_get_frame(&codec, &iter)) != NULL)
vpx_img_write(img, outfile);
} else {
putc('X', stdout);
}
fflush(stdout);
}
printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec))
die_codec(&codec, "Failed to destroy codec.");
printf("Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n",
info->frame_width, info->frame_height, argv[2]);
vpx_video_reader_close(reader);
fclose(outfile);
return EXIT_SUCCESS;
}
/****************************************************************************
* Decode: the whole thing
****************************************************************************/
static picture_t *Decode(decoder_t *dec, block_t **pp_block)
{
struct vpx_codec_ctx *ctx = &dec->p_sys->ctx;
block_t *block = *pp_block;
if (!block)
return NULL;
if (block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED))
return NULL;
/* Associate packet PTS with decoded frame */
mtime_t *pkt_pts = malloc(sizeof(*pkt_pts));
if (!pkt_pts) {
block_Release(block);
*pp_block = NULL;
return NULL;
}
*pkt_pts = block->i_pts;
vpx_codec_err_t err;
err = vpx_codec_decode(ctx, block->p_buffer, block->i_buffer, pkt_pts, 0);
block_Release(block);
*pp_block = NULL;
if (err != VPX_CODEC_OK) {
free(pkt_pts);
const char *error = vpx_codec_error(ctx);
const char *detail = vpx_codec_error_detail(ctx);
if (!detail)
detail = "no specific information";
msg_Err(dec, "Failed to decode frame: %s (%s)", error, detail);
return NULL;
}
const void *iter = NULL;
struct vpx_image *img = vpx_codec_get_frame(ctx, &iter);
if (!img) {
free(pkt_pts);
return NULL;
}
/* fetches back the PTS */
pkt_pts = img->user_priv;
mtime_t pts = *pkt_pts;
free(pkt_pts);
if (img->fmt != VPX_IMG_FMT_I420) {
msg_Err(dec, "Unsupported output colorspace %d", img->fmt);
return NULL;
}
video_format_t *v = &dec->fmt_out.video;
if (img->d_w != v->i_visible_width || img->d_h != v->i_visible_height) {
v->i_visible_width = img->d_w;
v->i_visible_height = img->d_h;
}
picture_t *pic = decoder_NewPicture(dec);
if (!pic)
return NULL;
for (int plane = 0; plane < pic->i_planes; plane++ ) {
uint8_t *src = img->planes[plane];
uint8_t *dst = pic->p[plane].p_pixels;
int src_stride = img->stride[plane];
int dst_stride = pic->p[plane].i_pitch;
int size = __MIN( src_stride, dst_stride );
for( int line = 0; line < pic->p[plane].i_visible_lines; line++ ) {
memcpy( dst, src, size );
src += src_stride;
dst += dst_stride;
}
}
pic->b_progressive = true; /* codec does not support interlacing */
pic->date = pts;
return pic;
}
int main_loop(int argc, const char **argv_) {
vpx_codec_ctx_t decoder;
char *fn = NULL;
int i;
uint8_t *buf = NULL;
size_t bytes_in_buffer = 0, buffer_size = 0;
FILE *infile;
int frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0;
int do_md5 = 0, progress = 0;
int stop_after = 0, postproc = 0, summary = 0, quiet = 1;
int arg_skip = 0;
int ec_enabled = 0;
const VpxInterface *interface = NULL;
const VpxInterface *fourcc_interface = NULL;
uint64_t dx_time = 0;
struct arg arg;
char **argv, **argi, **argj;
int single_file;
int use_y4m = 1;
vpx_codec_dec_cfg_t cfg = {0};
#if CONFIG_VP8_DECODER
vp8_postproc_cfg_t vp8_pp_cfg = {0};
int vp8_dbg_color_ref_frame = 0;
int vp8_dbg_color_mb_modes = 0;
int vp8_dbg_color_b_modes = 0;
int vp8_dbg_display_mv = 0;
#endif
int frames_corrupted = 0;
int dec_flags = 0;
int do_scale = 0;
vpx_image_t *scaled_img = NULL;
int frame_avail, got_data;
int num_external_frame_buffers = 0;
struct ExternalFrameBufferList ext_fb_list = {0};
const char *outfile_pattern = NULL;
char outfile_name[PATH_MAX] = {0};
FILE *outfile = NULL;
MD5Context md5_ctx;
unsigned char md5_digest[16];
struct VpxDecInputContext input = {0};
struct VpxInputContext vpx_input_ctx = {0};
struct WebmInputContext webm_ctx = {0};
input.vpx_input_ctx = &vpx_input_ctx;
input.webm_ctx = &webm_ctx;
/* Parse command line */
exec_name = argv_[0];
argv = argv_dup(argc - 1, argv_ + 1);
for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
memset(&arg, 0, sizeof(arg));
arg.argv_step = 1;
if (arg_match(&arg, &codecarg, argi)) {
interface = get_vpx_decoder_by_name(arg.val);
if (!interface)
die("Error: Unrecognized argument (%s) to --codec\n", arg.val);
} else if (arg_match(&arg, &looparg, argi)) {
// no-op
} else if (arg_match(&arg, &outputfile, argi))
outfile_pattern = arg.val;
else if (arg_match(&arg, &use_yv12, argi)) {
use_y4m = 0;
flipuv = 1;
} else if (arg_match(&arg, &use_i420, argi)) {
use_y4m = 0;
flipuv = 0;
} else if (arg_match(&arg, &flipuvarg, argi))
flipuv = 1;
else if (arg_match(&arg, &noblitarg, argi))
noblit = 1;
else if (arg_match(&arg, &progressarg, argi))
progress = 1;
else if (arg_match(&arg, &limitarg, argi))
stop_after = arg_parse_uint(&arg);
else if (arg_match(&arg, &skiparg, argi))
arg_skip = arg_parse_uint(&arg);
else if (arg_match(&arg, &postprocarg, argi))
postproc = 1;
else if (arg_match(&arg, &md5arg, argi))
do_md5 = 1;
else if (arg_match(&arg, &summaryarg, argi))
summary = 1;
else if (arg_match(&arg, &threadsarg, argi))
cfg.threads = arg_parse_uint(&arg);
else if (arg_match(&arg, &verbosearg, argi))
quiet = 0;
else if (arg_match(&arg, &scalearg, argi))
do_scale = 1;
else if (arg_match(&arg, &fb_arg, argi))
num_external_frame_buffers = arg_parse_uint(&arg);
#if CONFIG_VP8_DECODER
else if (arg_match(&arg, &addnoise_level, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_ADDNOISE;
vp8_pp_cfg.noise_level = arg_parse_uint(&arg);
} else if (arg_match(&arg, &demacroblock_level, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_DEMACROBLOCK;
vp8_pp_cfg.deblocking_level = arg_parse_uint(&arg);
} else if (arg_match(&arg, &deblock, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_DEBLOCK;
} else if (arg_match(&arg, &mfqe, argi)) {
postproc = 1;
vp8_pp_cfg.post_proc_flag |= VP8_MFQE;
} else if (arg_match(&arg, &pp_debug_info, argi)) {
unsigned int level = arg_parse_uint(&arg);
postproc = 1;
vp8_pp_cfg.post_proc_flag &= ~0x7;
if (level)
vp8_pp_cfg.post_proc_flag |= level;
} else if (arg_match(&arg, &pp_disp_ref_frame, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_color_ref_frame = flags;
}
} else if (arg_match(&arg, &pp_disp_mb_modes, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_color_mb_modes = flags;
}
} else if (arg_match(&arg, &pp_disp_b_modes, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_color_b_modes = flags;
}
} else if (arg_match(&arg, &pp_disp_mvs, argi)) {
unsigned int flags = arg_parse_int(&arg);
if (flags) {
postproc = 1;
vp8_dbg_display_mv = flags;
}
} else if (arg_match(&arg, &error_concealment, argi)) {
ec_enabled = 1;
}
#endif
else
argj++;
}
/* Check for unrecognized options */
for (argi = argv; *argi; argi++)
if (argi[0][0] == '-' && strlen(argi[0]) > 1)
die("Error: Unrecognized option %s\n", *argi);
/* Handle non-option arguments */
fn = argv[0];
if (!fn)
usage_exit();
/* Open file */
infile = strcmp(fn, "-") ? fopen(fn, "rb") : set_binary_mode(stdin);
if (!infile) {
fprintf(stderr, "Failed to open file '%s'", strcmp(fn, "-") ? fn : "stdin");
return EXIT_FAILURE;
}
#if CONFIG_OS_SUPPORT
/* Make sure we don't dump to the terminal, unless forced to with -o - */
if (!outfile_pattern && isatty(fileno(stdout)) && !do_md5 && !noblit) {
fprintf(stderr,
"Not dumping raw video to your terminal. Use '-o -' to "
"override.\n");
return EXIT_FAILURE;
}
#endif
input.vpx_input_ctx->file = infile;
if (file_is_ivf(input.vpx_input_ctx))
input.vpx_input_ctx->file_type = FILE_TYPE_IVF;
#if CONFIG_WEBM_IO
else if (file_is_webm(input.webm_ctx, input.vpx_input_ctx))
input.vpx_input_ctx->file_type = FILE_TYPE_WEBM;
#endif
else if (file_is_raw(input.vpx_input_ctx))
input.vpx_input_ctx->file_type = FILE_TYPE_RAW;
else {
fprintf(stderr, "Unrecognized input file type.\n");
#if !CONFIG_WEBM_IO
fprintf(stderr, "vpxdec was built without WebM container support.\n");
#endif
return EXIT_FAILURE;
}
outfile_pattern = outfile_pattern ? outfile_pattern : "-";
single_file = is_single_file(outfile_pattern);
if (!noblit && single_file) {
generate_filename(outfile_pattern, outfile_name, PATH_MAX,
vpx_input_ctx.width, vpx_input_ctx.height, 0);
if (do_md5)
MD5Init(&md5_ctx);
else
outfile = open_outfile(outfile_name);
}
if (use_y4m && !noblit) {
if (!single_file) {
fprintf(stderr, "YUV4MPEG2 not supported with output patterns,"
" try --i420 or --yv12.\n");
return EXIT_FAILURE;
}
#if CONFIG_WEBM_IO
if (vpx_input_ctx.file_type == FILE_TYPE_WEBM) {
if (webm_guess_framerate(input.webm_ctx, input.vpx_input_ctx)) {
fprintf(stderr, "Failed to guess framerate -- error parsing "
"webm file?\n");
return EXIT_FAILURE;
}
}
#endif
}
fourcc_interface = get_vpx_decoder_by_fourcc(vpx_input_ctx.fourcc);
if (interface && fourcc_interface && interface != fourcc_interface)
warn("Header indicates codec: %s\n", fourcc_interface->name);
else
interface = fourcc_interface;
if (!interface)
interface = get_vpx_decoder_by_index(0);
dec_flags = (postproc ? VPX_CODEC_USE_POSTPROC : 0) |
(ec_enabled ? VPX_CODEC_USE_ERROR_CONCEALMENT : 0);
if (vpx_codec_dec_init(&decoder, interface->interface(), &cfg, dec_flags)) {
fprintf(stderr, "Failed to initialize decoder: %s\n",
vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (!quiet)
fprintf(stderr, "%s\n", decoder.name);
#if CONFIG_VP8_DECODER
if (vp8_pp_cfg.post_proc_flag
&& vpx_codec_control(&decoder, VP8_SET_POSTPROC, &vp8_pp_cfg)) {
fprintf(stderr, "Failed to configure postproc: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_color_ref_frame
&& vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_REF_FRAME, vp8_dbg_color_ref_frame)) {
fprintf(stderr, "Failed to configure reference block visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_color_mb_modes
&& vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_MB_MODES, vp8_dbg_color_mb_modes)) {
fprintf(stderr, "Failed to configure macro block visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_color_b_modes
&& vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_B_MODES, vp8_dbg_color_b_modes)) {
fprintf(stderr, "Failed to configure block visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (vp8_dbg_display_mv
&& vpx_codec_control(&decoder, VP8_SET_DBG_DISPLAY_MV, vp8_dbg_display_mv)) {
fprintf(stderr, "Failed to configure motion vector visualizer: %s\n", vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
#endif
if (arg_skip)
fprintf(stderr, "Skipping first %d frames.\n", arg_skip);
while (arg_skip) {
if (read_frame(&input, &buf, &bytes_in_buffer, &buffer_size))
break;
arg_skip--;
}
if (num_external_frame_buffers > 0) {
ext_fb_list.num_external_frame_buffers = num_external_frame_buffers;
ext_fb_list.ext_fb = (struct ExternalFrameBuffer *)calloc(
num_external_frame_buffers, sizeof(*ext_fb_list.ext_fb));
if (vpx_codec_set_frame_buffer_functions(
&decoder, get_vp9_frame_buffer, release_vp9_frame_buffer,
&ext_fb_list)) {
fprintf(stderr, "Failed to configure external frame buffers: %s\n",
vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
}
frame_avail = 1;
got_data = 0;
/* Decode file */
while (frame_avail || got_data) {
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
struct vpx_usec_timer timer;
int corrupted;
frame_avail = 0;
if (!stop_after || frame_in < stop_after) {
if (!read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) {
frame_avail = 1;
frame_in++;
vpx_usec_timer_start(&timer);
if (vpx_codec_decode(&decoder, buf, (unsigned int)bytes_in_buffer,
NULL, 0)) {
const char *detail = vpx_codec_error_detail(&decoder);
warn("Failed to decode frame %d: %s",
frame_in, vpx_codec_error(&decoder));
if (detail)
warn("Additional information: %s", detail);
goto fail;
}
vpx_usec_timer_mark(&timer);
dx_time += vpx_usec_timer_elapsed(&timer);
}
}
vpx_usec_timer_start(&timer);
got_data = 0;
if ((img = vpx_codec_get_frame(&decoder, &iter))) {
++frame_out;
got_data = 1;
}
vpx_usec_timer_mark(&timer);
dx_time += (unsigned int)vpx_usec_timer_elapsed(&timer);
if (vpx_codec_control(&decoder, VP8D_GET_FRAME_CORRUPTED, &corrupted)) {
warn("Failed VP8_GET_FRAME_CORRUPTED: %s", vpx_codec_error(&decoder));
goto fail;
}
frames_corrupted += corrupted;
if (progress)
show_progress(frame_in, frame_out, dx_time);
if (!noblit && img) {
const int PLANES_YUV[] = {VPX_PLANE_Y, VPX_PLANE_U, VPX_PLANE_V};
const int PLANES_YVU[] = {VPX_PLANE_Y, VPX_PLANE_V, VPX_PLANE_U};
const int *planes = flipuv ? PLANES_YVU : PLANES_YUV;
if (do_scale) {
if (frame_out == 1) {
// If the output frames are to be scaled to a fixed display size then
// use the width and height specified in the container. If either of
// these is set to 0, use the display size set in the first frame
// header. If that is unavailable, use the raw decoded size of the
// first decoded frame.
int display_width = vpx_input_ctx.width;
int display_height = vpx_input_ctx.height;
if (!display_width || !display_height) {
int display_size[2];
if (vpx_codec_control(&decoder, VP9D_GET_DISPLAY_SIZE,
display_size)) {
// As last resort use size of first frame as display size.
display_width = img->d_w;
display_height = img->d_h;
} else {
display_width = display_size[0];
display_height = display_size[1];
}
}
scaled_img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, display_width,
display_height, 16);
}
if (img->d_w != scaled_img->d_w || img->d_h != scaled_img->d_h) {
vpx_image_scale(img, scaled_img, kFilterBox);
img = scaled_img;
}
}
if (single_file) {
if (use_y4m) {
char buf[Y4M_BUFFER_SIZE] = {0};
size_t len = 0;
if (frame_out == 1) {
// Y4M file header
len = y4m_write_file_header(buf, sizeof(buf),
vpx_input_ctx.width,
vpx_input_ctx.height,
&vpx_input_ctx.framerate, img->fmt);
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)buf, (unsigned int)len);
} else {
fputs(buf, outfile);
}
}
// Y4M frame header
len = y4m_write_frame_header(buf, sizeof(buf));
if (do_md5) {
MD5Update(&md5_ctx, (md5byte *)buf, (unsigned int)len);
} else {
fputs(buf, outfile);
}
}
if (do_md5) {
update_image_md5(img, planes, &md5_ctx);
} else {
write_image_file(img, planes, outfile);
}
} else {
generate_filename(outfile_pattern, outfile_name, PATH_MAX,
img->d_w, img->d_h, frame_in);
if (do_md5) {
MD5Init(&md5_ctx);
update_image_md5(img, planes, &md5_ctx);
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
outfile = open_outfile(outfile_name);
write_image_file(img, planes, outfile);
fclose(outfile);
}
}
}
if (stop_after && frame_in >= stop_after)
break;
}
if (summary || progress) {
show_progress(frame_in, frame_out, dx_time);
fprintf(stderr, "\n");
}
if (frames_corrupted)
fprintf(stderr, "WARNING: %d frames corrupted.\n", frames_corrupted);
fail:
if (vpx_codec_destroy(&decoder)) {
fprintf(stderr, "Failed to destroy decoder: %s\n",
vpx_codec_error(&decoder));
return EXIT_FAILURE;
}
if (!noblit && single_file) {
if (do_md5) {
MD5Final(md5_digest, &md5_ctx);
print_md5(md5_digest, outfile_name);
} else {
fclose(outfile);
}
}
#if CONFIG_WEBM_IO
if (input.vpx_input_ctx->file_type == FILE_TYPE_WEBM)
webm_free(input.webm_ctx);
#endif
if (input.vpx_input_ctx->file_type != FILE_TYPE_WEBM)
free(buf);
if (scaled_img) vpx_img_free(scaled_img);
for (i = 0; i < ext_fb_list.num_external_frame_buffers; ++i) {
free(ext_fb_list.ext_fb[i].data);
}
free(ext_fb_list.ext_fb);
fclose(infile);
free(argv);
return frames_corrupted ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char **argv) {
FILE *infile, *outfile;
vpx_codec_ctx_t codec;
vpx_codec_iface_t *iface;
int flags = 0, frame_cnt = 0;
unsigned char file_hdr[IVF_FILE_HDR_SZ];
unsigned char frame_hdr[IVF_FRAME_HDR_SZ];
unsigned char frame[256 * 1024];
if (argc != 3)
die("Usage: %s <infile> <outfile>\n", argv[0]);
if (!(infile = fopen(argv[1], "rb")))
die("Failed to open %s for reading", argv[1]);
if (!(outfile = fopen(argv[2], "wb")))
die("Failed to open %s for writing", argv[2]);
if (!(fread(file_hdr, 1, IVF_FILE_HDR_SZ, infile) == IVF_FILE_HDR_SZ &&
file_hdr[0] == 'D' && file_hdr[1] == 'K' &&
file_hdr[2] == 'I' && file_hdr[3] == 'F'))
die("%s is not an IVF file.", argv[1]);
iface = get_codec_interface(mem_get_le32(file_hdr + 8));
if (!iface)
die("Unknown FOURCC code.");
printf("Using %s\n", vpx_codec_iface_name(iface));
if (vpx_codec_dec_init(&codec, iface, NULL, flags))
die_codec(&codec, "Failed to initialize decoder");
while (fread(frame_hdr, 1, IVF_FRAME_HDR_SZ, infile) == IVF_FRAME_HDR_SZ) {
const int frame_size = mem_get_le32(frame_hdr);
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
if (frame_size > sizeof(frame))
die("Frame %d data too big for example code buffer", frame_size);
if (fread(frame, 1, frame_size, infile) != frame_size)
die("Failed to read complete frame");
if (vpx_codec_decode(&codec, frame, frame_size, NULL, 0))
die_codec(&codec, "Failed to decode frame");
while ((img = vpx_codec_get_frame(&codec, &iter)) != NULL) {
unsigned char digest[16];
get_image_md5(img, digest);
print_md5(outfile, digest);
fprintf(outfile, " img-%dx%d-%04d.i420\n",
img->d_w, img->d_h, ++frame_cnt);
}
}
printf("Processed %d frames.\n", frame_cnt);
if (vpx_codec_destroy(&codec))
die_codec(&codec, "Failed to destroy codec");
fclose(outfile);
fclose(infile);
return EXIT_SUCCESS;
}
void cs_do(CSSession *cs)
{
/* Codec session should always be protected by call mutex so no need to check for cs validity
*/
if (!cs) return;
Payload *p;
int rc;
int success = 0;
pthread_mutex_lock(cs->queue_mutex);
RTPMessage *msg;
while ((msg = jbuf_read(cs->j_buf, &success)) || success == 2) {
pthread_mutex_unlock(cs->queue_mutex);
uint16_t fsize = ((cs->audio_decoder_sample_rate * cs->audio_decoder_frame_duration) / 1000);
int16_t tmp[fsize * cs->audio_decoder_channels];
if (success == 2) {
rc = opus_decode(cs->audio_decoder, 0, 0, tmp, fsize, 1);
} else {
rc = opus_decode(cs->audio_decoder, msg->data, msg->length, tmp, fsize, 0);
rtp_free_msg(NULL, msg);
}
if (rc < 0) {
LOGGER_WARNING("Decoding error: %s", opus_strerror(rc));
} else if (cs->acb.first) {
/* Play */
cs->acb.first(cs->agent, cs->call_idx, tmp, rc, cs->acb.second);
}
pthread_mutex_lock(cs->queue_mutex);
}
if (cs->vbuf_raw && !buffer_empty(cs->vbuf_raw)) {
/* Decode video */
buffer_read(cs->vbuf_raw, &p);
/* Leave space for (possibly) other thread to queue more data after we read it here */
pthread_mutex_unlock(cs->queue_mutex);
rc = vpx_codec_decode(&cs->v_decoder, p->data, p->size, NULL, MAX_DECODE_TIME_US);
free(p);
if (rc != VPX_CODEC_OK) {
LOGGER_ERROR("Error decoding video: %s", vpx_codec_err_to_string(rc));
} else {
vpx_codec_iter_t iter = NULL;
vpx_image_t *dest = vpx_codec_get_frame(&cs->v_decoder, &iter);
/* Play decoded images */
for (; dest; dest = vpx_codec_get_frame(&cs->v_decoder, &iter)) {
if (cs->vcb.first)
cs->vcb.first(cs->agent, cs->call_idx, dest, cs->vcb.second);
vpx_img_free(dest);
}
}
return;
}
pthread_mutex_unlock(cs->queue_mutex);
}