自学教程：C++ sws_getCachedContext函数代码示例

JNIEXPORT jint JNICALL Java_com_jazzros_ffmpegtest_AVThread_nativeUpdateBitmap(JNIEnv* env, jobject thiz){    //ros: gSwsContext = sws_getCachedContext(gSwsContext, gVideoCodecCtx->width, gVideoCodecCtx->height, gVideoCodecCtx->pix_fmt, gAbi.width, gAbi.height, AV_PIX_FMT_RGB565LE, SWS_FAST_BILINEAR, NULL, NULL, NULL);    gSwsContext = sws_getCachedContext(gSwsContext, gVideoCodecCtx->width, gVideoCodecCtx->height, gVideoCodecCtx->pix_fmt, gAbi.width, gAbi.height, AV_PIX_FMT_RGB565LE, SWS_FAST_BILINEAR, NULL, NULL, NULL);    if (gSwsContext == 0)    {        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "sws_getCachedContext() failed");        return -1;    }    AVPicture pict;    //ros: int size = avpicture_fill(&pict, gBitmapRefPixelBuffer, AV_PIX_FMT_RGB565LE, gAbi.width, gAbi.height);    int size = avpicture_fill(&pict, gBitmapRefPixelBuffer, AV_PIX_FMT_RGB565LE, gAbi.width, gAbi.height);    if (size != gAbi.stride * gAbi.height)    {        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "size != gAbi.stride * gAbi.height");        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "size = %d", size);        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "gAbi.stride * gAbi.height = %d", gAbi.stride * gAbi.height);        return -2;    }    int height = sws_scale(gSwsContext, (const uint8_t* const*)gVideoFrame->data, gVideoFrame->linesize, 0, gVideoCodecCtx->height, pict.data, pict.linesize);    if (height != gAbi.height)    {        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "height != gAbi.height");        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "height = %d", height);        __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "gAbi.height = %d", gAbi.height);        return -3;    }    return 0;}

void MediaEngine::updateSwsFormat(int videoPixelMode) {#ifdef USE_FFMPEG	auto codecIter = m_pCodecCtxs.find(m_videoStream);	AVCodecContext *m_pCodecCtx = codecIter == m_pCodecCtxs.end() ? 0 : codecIter->second;	AVPixelFormat swsDesired = getSwsFormat(videoPixelMode);	if (swsDesired != m_sws_fmt && m_pCodecCtx != 0) {		m_sws_fmt = swsDesired;		m_sws_ctx = sws_getCachedContext			(				m_sws_ctx,				m_pCodecCtx->width,				m_pCodecCtx->height,				m_pCodecCtx->pix_fmt,				m_desWidth,				m_desHeight,				(AVPixelFormat)m_sws_fmt,				SWS_BILINEAR,				NULL,				NULL,				NULL			);	}#endif}

void RasterRenderPrivate::drawData(QPainter *painter, QRect rect){	if (!srcFrame->isValid()){		return;	}	QRect dest = fitRect(ARender::instance()->getPreferSize(), rect);	QSize dstSize = dest.size()*painter->device()->devicePixelRatio();	if (!dstFrame || dstFrame->size != dstSize){		delete dstFrame;		dstFrame = new Buffer(AV_PIX_FMT_RGB32, dstSize, 4);		frame = QImage(*dstFrame->data, dstSize.width(), dstSize.height(), QImage::Format_RGB32);		dirty = true;	}	if (dirty){		swsctx = sws_getCachedContext(swsctx,			srcFrame->size.width(), srcFrame->size.height(), srcFrame->format,			dstFrame->size.width(), dstFrame->size.height(), dstFrame->format,			SWS_FAST_BILINEAR, NULL, NULL, NULL);		dataLock.lock();		sws_scale(swsctx,			srcFrame->data, srcFrame->width,			0, srcFrame->size.height(),			dstFrame->data, dstFrame->width);		dirty = false;		dataLock.unlock();	}	painter->drawImage(dest, frame);}

int32_t avbin_decode_video(AVbinStream *stream,                       uint8_t *data_in, size_t size_in,                       uint8_t *data_out){    AVPicture picture_rgb;    int got_picture;    int width = stream->codec_context->width;    int height = stream->codec_context->height;    int used;    if (stream->type != AVMEDIA_TYPE_VIDEO)        return AVBIN_RESULT_ERROR;    AVPacket packet;    av_init_packet(&packet);    packet.data = data_in;    packet.size = size_in;    used = avcodec_decode_video2(stream->codec_context,                                stream->frame, &got_picture,                                &packet);    if (!got_picture)        return AVBIN_RESULT_ERROR;    avpicture_fill(&picture_rgb, data_out, PIX_FMT_RGB24, width, height);    static struct SwsContext *img_convert_ctx = NULL;    img_convert_ctx = sws_getCachedContext(img_convert_ctx,width, height,stream->codec_context->pix_fmt,width, height,PIX_FMT_RGB24, SWS_FAST_BILINEAR, NULL, NULL, NULL);    sws_scale(img_convert_ctx, (const uint8_t* const*)stream->frame->data, stream->frame->linesize,0, height, picture_rgb.data, picture_rgb.linesize);    return used;}

bool FFDecSW::open( StreamInfo *streamInfo, Writer * ){	AVCodec *codec = FFDec::init( streamInfo );	if ( !codec )		return false;	if ( codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO )	{		if ( codec_ctx->pix_fmt == AV_PIX_FMT_NONE || streamInfo->W <= 0 || streamInfo->H <= 0 )			return false;		if ( codec->capabilities & CODEC_CAP_DR1 )			codec_ctx->flags |= CODEC_FLAG_EMU_EDGE;		if ( ( codec_ctx->thread_count = threads ) > 1 )		{			if ( !thread_type_slice )				codec_ctx->thread_type = FF_THREAD_FRAME;			else				codec_ctx->thread_type = FF_THREAD_SLICE;		}		if ( codec_ctx->codec_id != CODEC_ID_H264 && codec_ctx->codec_id != CODEC_ID_VP8 )			codec_ctx->lowres = lowres;	}	if ( !FFDec::openCodec( codec ) )		return false;	if ( codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO )	{		if ( codec_ctx->lowres )		{			streamInfo->W = codec_ctx->width;			streamInfo->H = codec_ctx->height;		}		sws_ctx = sws_getCachedContext( NULL, streamInfo->W, streamInfo->H, codec_ctx->pix_fmt, streamInfo->W, streamInfo->H, AV_PIX_FMT_YUV420P, SWS_POINT, NULL, NULL, NULL );	}	return true;}

int getThumbnail(AVFrame* pInputFrame, AVFrame* pOutputFrame, int desW, int desH){    if (pInputFrame == NULL || pOutputFrame == NULL)    {        return -1;    }    SwsContext* pSwsContext = NULL;    pSwsContext = sws_getCachedContext(pSwsContext, pInputFrame->width, pInputFrame->height, (AVPixelFormat)pInputFrame->format,                                       desW, desH, AV_PIX_FMT_RGB565, SWS_BICUBIC, NULL, NULL, NULL);    if (pSwsContext == NULL)    {        return -1;    }    m_pThumbFrame->width = desW;    m_pThumbFrame->height = desH;    m_pThumbFrame->format = AV_PIX_FMT_RGB565;    av_frame_get_buffer(m_pThumbFrame, 16);    sws_scale(pSwsContext, pInputFrame->data, pInputFrame->linesize, 0, pInputFrame->height, m_pThumbFrame->data, m_pThumbFrame->linesize);    sws_freeContext(pSwsContext);    return 0;}

int decodeFrame(){	int frameFinished = 0;	AVPacket packet;	while(av_read_frame(gFormatCtx, &packet)>=0) {		if(packet.stream_index == gVideoStreamIdx){			avcodec_decode_video2(gVideoCodecCtx, gFrame, &frameFinished, &packet);			if(frameFinished){				gImgConvertCtx = sws_getCachedContext(gImgConvertCtx, gVideoCodecCtx->width, gVideoCodecCtx->height,						gVideoCodecCtx->pix_fmt, gVideoCodecCtx->width, gVideoCodecCtx->height,						PIX_FMT_RGB565LE, SWS_BICUBIC, NULL, NULL, NULL);				sws_scale(gImgConvertCtx, gFrame->data, gFrame->linesize, 0, gVideoCodecCtx->height,						gFrameRGB->data,gFrameRGB->linesize);				av_free_packet(&packet);				return 0;			}		}		av_free_packet(&packet);	}	return -1;}

static bool mp_media_init_scaling(mp_media_t *m){	int space = get_sws_colorspace(m->v.decoder->colorspace);	int range = get_sws_range(m->v.decoder->color_range);	const int *coeff = sws_getCoefficients(space);	m->swscale = sws_getCachedContext(NULL,			m->v.decoder->width, m->v.decoder->height,			m->v.decoder->pix_fmt,			m->v.decoder->width, m->v.decoder->height,			m->scale_format,			SWS_FAST_BILINEAR, NULL, NULL, NULL);	if (!m->swscale) {		blog(LOG_WARNING, "MP: Failed to initialize scaler");		return false;	}	sws_setColorspaceDetails(m->swscale, coeff, range, coeff, range, 0,			FIXED_1_0, FIXED_1_0);	int ret = av_image_alloc(m->scale_pic, m->scale_linesizes,			m->v.decoder->width, m->v.decoder->height,			m->scale_format, 1);	if (ret < 0) {		blog(LOG_WARNING, "MP: Failed to create scale pic data");		return false;	}	return true;}

static bool swscale(unsigned char *src, unsigned char *dst, int sw, int sh, int dw, int dh){	bool ret = false;	struct SwsContext *scale = NULL;	AVFrame *sframe, *dframe;	scale = sws_getCachedContext(scale, sw, sh, PIX_FMT_RGB32, dw, dh, PIX_FMT_RGB32, SWS_BICUBIC, 0, 0, 0);	if (!scale) {		lt_info_c("%s: ERROR setting up SWS context/n", __func__);		return false;	}	sframe = av_frame_alloc();	dframe = av_frame_alloc();	if (!sframe || !dframe) {		lt_info_c("%s: could not alloc sframe (%p) or dframe (%p)/n", __func__, sframe, dframe);		goto out;	}	avpicture_fill((AVPicture *)sframe, &(src[0]), PIX_FMT_RGB32, sw, sh);	avpicture_fill((AVPicture *)dframe, &(dst[0]), PIX_FMT_RGB32, dw, dh);	sws_scale(scale, sframe->data, sframe->linesize, 0, sh, dframe->data, dframe->linesize); out:	av_frame_free(&sframe);	av_frame_free(&dframe);	sws_freeContext(scale);	return ret;}

static void ffmpeg_encoder_scale(void) {    sws_context = sws_getCachedContext(sws_context,            frame->width, frame->height, AV_PIX_FMT_YUV420P,            frame2->width, frame2->height, AV_PIX_FMT_YUV420P,            SWS_BICUBIC, NULL, NULL, NULL);    sws_scale(sws_context, (const uint8_t * const *)frame->data, frame->linesize, 0,            frame->height, frame2->data, frame2->linesize);}

int DecoderHelper::DecodeVideo(char *inBuff, int inBuffSize, void *yuvBuff, int width, int height){	if (NULL == inBuff)			return -1;	if (1 > inBuffSize)			return -1;	if (NULL == yuvBuff)		return -1;	if (NULL == _videoCodecContext)		return -2;	_videoAVPacket.size = inBuffSize;	_videoAVPacket.data	= (uint8_t*)inBuff;	int frameFinished = 0;	int nDecode = avcodec_decode_video2(_videoCodecContext, _videoFrame420, &frameFinished, &_videoAVPacket);//(uint8_t*)pInBuffer, inputSize);	if (nDecode < 0)	return -3;	if (!frameFinished)	return -4;	if  (width != _width || height != _height)	{		if (NULL != _avframeYUV)		{			av_frame_free(&_avframeYUV);			_avframeYUV = NULL;		}		if (NULL != _swsContext)		{			sws_freeContext(_swsContext);			_swsContext = NULL;		}		_width = width;		_height = height;	}	if (NULL == _avframeYUV)	{		int numBytes = avpicture_get_size((AVPixelFormat)_outputFormat, width, height);		_avframeYUV = av_frame_alloc();	}	if (NULL == _avframeYUV)		return -5;	if (avpicture_fill((AVPicture *)_avframeYUV, (uint8_t*)yuvBuff, (AVPixelFormat)_outputFormat,		width, height) < 0)	{		return -1;	}	if (NULL == _swsContext)	{		_swsContext = sws_getCachedContext(_swsContext, _videoCodecContext->width, _videoCodecContext->height, (AVPixelFormat)AV_PIX_FMT_YUV420P, 			width, height, (AVPixelFormat)_outputFormat, SWS_BICUBIC, NULL, NULL, NULL);	}	if (NULL == _swsContext)		return -1;	int ret = sws_scale(_swsContext, _videoFrame420->data, _videoFrame420->linesize, 0, _videoCodecContext->height, 		_avframeYUV->data, _avframeYUV->linesize);	return 0;}

void LiveStreamFrameFormatter::updateSWSContext(){    m_sws_context = sws_getCachedContext(m_sws_context,                                         m_stream->codec->width, m_stream->codec->height,                                         m_stream->codec->pix_fmt,                                         m_stream->codec->width, m_stream->codec->height,                                         m_pixelFormat,                                         SWS_BICUBIC, NULL, NULL, NULL);}

/*Convert RGB24 array to YUV. Save directly to the `frame`,modifying its `data` and `linesize` fields*/static void ffmpeg_encoder_set_frame_yuv_from_rgb(uint8_t *rgb) {    const int in_linesize[1] = { 3 * c->width };    sws_context = sws_getCachedContext(sws_context,            c->width, c->height, AV_PIX_FMT_RGB24,            c->width, c->height, AV_PIX_FMT_YUV420P,            0, NULL, NULL, NULL);    sws_scale(sws_context, (const uint8_t * const *)&rgb, in_linesize, 0,            c->height, frame->data, frame->linesize);}

bool video_recording_state_t::init_sws_context(void){	AVCodecContext *c = video_stream->codec;	sws_context = sws_getCachedContext(sws_context, c->width, c->height, (enum AVPixelFormat)video_frame_raw->format,									   c->width, c->height, AV_PIX_FMT_YUV420P,									   SWS_BICUBIC, NULL, NULL, NULL);	if (!sws_context) return false;	return true;}

/*************************************************************************** Process one frame with ffmpeg-libavfilter*************************************************************************/static int convert_picture(vf_wrapper_t * wrapper, dt_av_frame_t * src){    uint8_t *buffer;    int buffer_size;    vf_ffmpeg_ctx_t *vf_ctx = (vf_ffmpeg_ctx_t *)(wrapper->vf_priv);    dtvideo_para_t *para = &wrapper->para;    int sw = para->s_width;    int dw = para->d_width;    int sh = para->s_height;    int dh = para->d_height;    int sf = para->s_pixfmt;    int df = para->d_pixfmt;    if (!vf_ctx->swap_frame) {        vf_ctx->swap_frame = (dt_av_frame_t *)malloc(sizeof(dt_av_frame_t));    }    dt_av_frame_t *pict = vf_ctx->swap_frame;    if (!pict) {        dt_error(TAG, "[%s:%d] err: swap frame malloc failed /n", __FUNCTION__,                 __LINE__);        return -1;    }    memset(pict, 0, sizeof(dt_av_frame_t));    AVPicture *dst = (AVPicture *)pict;    buffer_size = avpicture_get_size(df, dw, dh);    if (buffer_size > vf_ctx->swap_buf_size) {        if (vf_ctx->swapbuf) {            free(vf_ctx->swapbuf);        }        vf_ctx->swap_buf_size = buffer_size;        vf_ctx->swapbuf = (uint8_t *) malloc(buffer_size * sizeof(uint8_t));    }    buffer = vf_ctx->swapbuf;    avpicture_fill((AVPicture *) dst, buffer, df, dw, dh);    vf_ctx->pSwsCtx = sws_getCachedContext(vf_ctx->pSwsCtx, sw, sh, sf, dw, dh, df,                                           SWS_BICUBIC, NULL, NULL, NULL);    sws_scale(vf_ctx->pSwsCtx, src->data, src->linesize, 0, sh, dst->data,              dst->linesize);    pict->pts = src->pts;    pict->width = dw;    pict->height = dh;    pict->pixfmt = df;    if (src->data) {        free(src->data[0]);    }    memcpy(src, pict, sizeof(dt_av_frame_t));    vf_ctx->swapbuf = NULL;    vf_ctx->swap_buf_size = 0;    return 0;}

int FfmpegCamera::PrimeCapture(){    Info( "Priming capture from %s", mPath.c_str() );    // Open the input, not necessarily a file    if ( av_open_input_file( &mFormatContext, mPath.c_str(), NULL, 0, NULL ) !=0 )        Fatal( "Unable to open input %s due to: %s", mPath.c_str(), strerror(errno) );    // Locate stream info from input    if ( av_find_stream_info( mFormatContext ) < 0 )        Fatal( "Unable to find stream info from %s due to: %s", mPath.c_str(), strerror(errno) );        // Find first video stream present    mVideoStreamId = -1;    for ( int i=0; i < mFormatContext->nb_streams; i++ )    {        if ( mFormatContext->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO )        {            mVideoStreamId = i;            break;        }    }    if ( mVideoStreamId == -1 )        Fatal( "Unable to locate video stream in %s", mPath.c_str() );    mCodecContext = mFormatContext->streams[mVideoStreamId]->codec;    // Try and get the codec from the codec context    if ( (mCodec = avcodec_find_decoder( mCodecContext->codec_id )) == NULL )        Fatal( "Can't find codec for video stream from %s", mPath.c_str() );    // Open the codec    if ( avcodec_open( mCodecContext, mCodec ) < 0 )        Fatal( "Unable to open codec for video stream from %s", mPath.c_str() );    // Allocate space for the native video frame    mRawFrame = avcodec_alloc_frame();    // Allocate space for the converted video frame    mFrame = avcodec_alloc_frame();    // Determine required buffer size and allocate buffer    int pictureSize = avpicture_get_size( PIX_FMT_RGB24, mCodecContext->width, mCodecContext->height );    mBuffer.size( pictureSize );        avpicture_fill( (AVPicture *)mFrame, (unsigned char *)mBuffer, PIX_FMT_RGB24, mCodecContext->width, mCodecContext->height);#if HAVE_LIBSWSCALE    if ( (mConvertContext = sws_getCachedContext( mConvertContext, mCodecContext->width, mCodecContext->height, mCodecContext->pix_fmt, width, height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL )) == NULL )        Fatal( "Unable to create conversion context for %s", mPath.c_str() );#else // HAVE_LIBSWSCALE    Fatal( "You must compile ffmpeg with the --enable-swscale option to use ffmpeg cameras" );#endif // HAVE_LIBSWSCALE    return( 0 );}

static int vo_x11_vfmt2rgb (AVPicture * dst, AVPicture * src){    static struct SwsContext *img_convert_ctx;    img_convert_ctx = sws_getCachedContext (img_convert_ctx, dlpctxp->pwidth, dlpctxp->pheight, src_pic_fmt, dw, dh, my_pic_fmt, SWS_BICUBIC, NULL, NULL, NULL);    sws_scale (img_convert_ctx, src->data, src->linesize, 0, dh, dst->data, dst->linesize);    return 0;}

void CFFmpegPlayer::setOutputSize(int width, int height) {    if (m_outputWidth == width && m_outputHeight == height)        return;    m_outputWidth = width;    m_outputHeight = height;    m_swsCtx = sws_getCachedContext(        m_swsCtx, m_codecCtx->width, m_codecCtx->height,        m_codecCtx->pix_fmt, width, height,        AV_PIX_FMT_BGRA, SWS_POINT, nullptr, nullptr, nullptr);    m_pixelSize = GetGLPixelSize(GL_BGRA);}

void PhVideoDecoder::frameToRgb(AVFrame *avFrame, PhVideoBuffer *buffer){	int frameHeight = avFrame->height;	if(_deinterlace)		frameHeight = avFrame->height / 2;	// As the following formats are deprecated (see https://libav.org/doxygen/master/pixfmt_8h.html#a9a8e335cf3be472042bc9f0cf80cd4c5)	// we replace its with the new ones recommended by LibAv	// in order to get ride of the warnings	AVPixelFormat pixFormat;	switch (_videoStream->codec->pix_fmt) {	case AV_PIX_FMT_YUVJ420P:		pixFormat = AV_PIX_FMT_YUV420P;		break;	case AV_PIX_FMT_YUVJ422P:		pixFormat = AV_PIX_FMT_YUV422P;		break;	case AV_PIX_FMT_YUVJ444P:		pixFormat = AV_PIX_FMT_YUV444P;		break;	case AV_PIX_FMT_YUVJ440P:		pixFormat = AV_PIX_FMT_YUV440P;		break;	default:		pixFormat = _videoStream->codec->pix_fmt;		break;	}	/* Note: we output the frames in AV_PIX_FMT_BGRA rather than AV_PIX_FMT_RGB24,	 * because this format is native to most video cards and will avoid a conversion	 * in the video driver */	/* sws_getCachedContext will check if the context is valid for the given parameters. It the context is not valid,	 * it will be freed and a new one will be allocated. */	_swsContext = sws_getCachedContext(_swsContext, avFrame->width, _videoStream->codec->height, pixFormat,	                                   _videoStream->codec->width, frameHeight, AV_PIX_FMT_BGRA,	                                   SWS_POINT, NULL, NULL, NULL);	int linesize = avFrame->width * 4;	uint8_t *rgb = buffer->rgb();	if (0 <= sws_scale(_swsContext, (const uint8_t * const *) avFrame->data,	                   avFrame->linesize, 0, _videoStream->codec->height, &rgb,	                   &linesize)) {		PhFrame frame = AVTimestamp_to_PhFrame(av_frame_get_best_effort_timestamp(avFrame));		buffer->setFrame(frame);		buffer->setWidth(avFrame->width);		buffer->setHeight(frameHeight);		// tell the video engine that we have finished decoding!		emit frameAvailable(buffer);	}}

int THMoviePictureBuffer::write(AVFrame* pFrame, double dPts){    THMoviePicture* pMoviePicture = nullptr;    SDL_LockMutex(m_pMutex);    while(full() && !m_fAborting)    {        SDL_CondWait(m_pCond, m_pMutex);    }    SDL_UnlockMutex(m_pMutex);    if(m_fAborting) { return -1; }    pMoviePicture = &m_aPictureQueue[m_iWriteIndex];    SDL_LockMutex(pMoviePicture->m_pMutex);    if(pMoviePicture->m_pTexture)    {        m_pSwsContext = sws_getCachedContext(m_pSwsContext, pFrame->width, pFrame->height, (PixelFormat)pFrame->format, pMoviePicture->m_iWidth, pMoviePicture->m_iHeight, pMoviePicture->m_pixelFormat, SWS_BICUBIC, nullptr, nullptr, nullptr);        if(m_pSwsContext == nullptr)        {            SDL_UnlockMutex(m_aPictureQueue[m_iWriteIndex].m_pMutex);            std::cerr << "Failed to initialize SwsContext/n";            return 1;        }        /* Allocate a new frame and buffer for the destination RGB24 data. */        AVFrame *pFrameRGB = av_frame_alloc();        int numBytes = avpicture_get_size(pMoviePicture->m_pixelFormat, pMoviePicture->m_iWidth, pMoviePicture->m_iHeight);        uint8_t *buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));        avpicture_fill((AVPicture *)pFrameRGB, buffer, pMoviePicture->m_pixelFormat, pMoviePicture->m_iWidth, pMoviePicture->m_iHeight);        /* Rescale the frame data and convert it to RGB24. */        sws_scale(m_pSwsContext, pFrame->data, pFrame->linesize, 0, pMoviePicture->m_iHeight, pFrameRGB->data, pFrameRGB->linesize);        /* Upload it to the texture we render from - note that this works because our OpenGL context shares texture namespace with the main threads' context. */        SDL_UpdateTexture(pMoviePicture->m_pTexture, nullptr, buffer, pMoviePicture->m_iWidth * 3);        av_free(buffer);        av_frame_free(&pFrameRGB);        pMoviePicture->m_dPts = dPts;        SDL_UnlockMutex(m_aPictureQueue[m_iWriteIndex].m_pMutex);        m_iWriteIndex++;        if(m_iWriteIndex == PICTURE_BUFFER_SIZE)        {            m_iWriteIndex = 0;        }        SDL_LockMutex(m_pMutex);        m_iCount++;        SDL_UnlockMutex(m_pMutex);    }    return 0;}

int THMoviePictureBuffer::write(AVFrame* pFrame, double dPts){    THMoviePicture* pMoviePicture = nullptr;    SDL_LockMutex(m_pMutex);    while(full() && !m_fAborting)    {        SDL_CondWait(m_pCond, m_pMutex);    }    SDL_UnlockMutex(m_pMutex);    if(m_fAborting) { return -1; }    pMoviePicture = &m_aPictureQueue[m_iWriteIndex];    SDL_LockMutex(pMoviePicture->m_pMutex);    if(pMoviePicture->m_pBuffer)    {        m_pSwsContext = sws_getCachedContext(m_pSwsContext, pFrame->width, pFrame->height, (AVPixelFormat)pFrame->format, pMoviePicture->m_iWidth, pMoviePicture->m_iHeight, pMoviePicture->m_pixelFormat, SWS_BICUBIC, nullptr, nullptr, nullptr);        if(m_pSwsContext == nullptr)        {            SDL_UnlockMutex(m_aPictureQueue[m_iWriteIndex].m_pMutex);            std::cerr << "Failed to initialize SwsContext/n";            return 1;        }        /* Allocate a new frame and buffer for the destination RGB24 data. */        AVFrame *pFrameRGB = av_frame_alloc();#if (defined(CORSIX_TH_USE_LIBAV) && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(54, 6, 0)) || /    (defined(CORSIX_TH_USE_FFMPEG) && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51, 63, 100))        av_image_fill_arrays(pFrameRGB->data, pFrameRGB->linesize, pMoviePicture->m_pBuffer, pMoviePicture->m_pixelFormat, pMoviePicture->m_iWidth, pMoviePicture->m_iHeight, 1);#else        avpicture_fill((AVPicture *)pFrameRGB, pMoviePicture->m_pBuffer, pMoviePicture->m_pixelFormat, pMoviePicture->m_iWidth, pMoviePicture->m_iHeight);#endif        /* Rescale the frame data and convert it to RGB24. */        sws_scale(m_pSwsContext, pFrame->data, pFrame->linesize, 0, pFrame->height, pFrameRGB->data, pFrameRGB->linesize);        av_frame_free(&pFrameRGB);        pMoviePicture->m_dPts = dPts;        SDL_UnlockMutex(m_aPictureQueue[m_iWriteIndex].m_pMutex);        m_iWriteIndex++;        if(m_iWriteIndex == ms_pictureBufferSize)        {            m_iWriteIndex = 0;        }        SDL_LockMutex(m_pMutex);        m_iCount++;        SDL_UnlockMutex(m_pMutex);    }    return 0;}

// LibAvW_PlayGetFrameImageDLL_EXPORT int LibAvW_PlayGetFrameImage(void *stream, int pixel_format, void *imagedata, int imagewidth, int imageheight, int scaler){	avwstream_t *s;	PixelFormat avpixelformat;	int avscaler;	// check	if (!libav_initialized)		return 0;	s = (avwstream_t *)stream;	if (!s)		return 0;	// get pixel format	if (pixel_format == LIBAVW_PIXEL_FORMAT_BGR)		avpixelformat = PIX_FMT_BGR24;	else if (pixel_format == LIBAVW_PIXEL_FORMAT_BGRA)		avpixelformat = PIX_FMT_BGRA;	else	{		s->lasterror = LIBAVW_ERROR_BAD_PIXEL_FORMAT;		return 0;	}	// get scaler	if (scaler >= LIBAVW_SCALER_BILINEAR && scaler <= LIBAVW_SCALER_SPLINE)		avscaler = libav_scalers[scaler];	else	{		s->lasterror = LIBAVW_ERROR_CREATE_SCALE_CONTEXT;		return 0;	}	// get AV_InputFrame	avpicture_fill((AVPicture *)s->AV_OutputFrame, (uint8_t *)imagedata, avpixelformat, imagewidth, imageheight);	SwsContext *scale_context = sws_getCachedContext(NULL, s->AV_InputFrame->width, s->AV_InputFrame->height, (PixelFormat)s->AV_InputFrame->format, s->framewidth, s->frameheight, avpixelformat, avscaler, NULL, NULL, NULL); 	if (!scale_context)	{		s->lasterror = LIBAVW_ERROR_BAD_SCALER;		return 0;	}	if (!sws_scale(scale_context, s->AV_InputFrame->data, s->AV_InputFrame->linesize, 0, s->AV_InputFrame->height, s->AV_OutputFrame->data, s->AV_OutputFrame->linesize))	{		s->lasterror = LIBAVW_ERROR_APPLYING_SCALE;		sws_freeContext(scale_context); 		return 0;	}	// allright	s->lasterror = LIBAVW_ERROR_NONE;	sws_freeContext(scale_context); 	return 1;}

void Java_com_richitec_imeeting_video_ECVideoEncoder_processRawFrame(		JNIEnv* env, jobject thiz, jbyteArray buffer, jint width, jint height,		jint rotateDegree) {	if (!qvo || !is_video_encode_ready) {		return;	}//	D("process raw frame - width: %d height: %d", width, height);	jint rotateWidth, rotateHeight;	AVCodecContext *c = qvo->video_stream->codec;	jbyte *p_buffer_array = (*env)->GetByteArrayElements(env, buffer, 0);//	D("process raw frame - rotate degree: %d", rotateDegree);	unsigned char * p_rotated_buffer = rotateYUV420SP(p_buffer_array, width,			height, rotateDegree, &rotateWidth, &rotateHeight);	if (!p_rotated_buffer) {		(*env)->ReleaseByteArrayElements(env, buffer, p_buffer_array,				JNI_ABORT);		return;	}	avpicture_fill((AVPicture *) tmp_picture, p_rotated_buffer, src_pix_fmt,			rotateWidth, rotateHeight);//	D("avpicture fill ok");	(*env)->ReleaseByteArrayElements(env, buffer, p_buffer_array, JNI_ABORT);	img_convert_ctx = sws_getCachedContext(img_convert_ctx, rotateWidth,			rotateHeight, src_pix_fmt, qvo->width, qvo->height, c->pix_fmt,			SWS_BILINEAR, NULL, NULL, NULL);	sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize, 0,			rotateHeight, raw_picture->data, raw_picture->linesize);	int out_size = write_video_frame(qvo, raw_picture);//	D(//			"stream pts val: %lld time base: %d / %d", qvo->video_stream->pts.val, qvo->video_stream->time_base.num, qvo->video_stream->time_base.den);//	double video_pts = (double) qvo->video_stream->pts.val//			* qvo->video_stream->time_base.num//			/ qvo->video_stream->time_base.den;//	D("write video frame - size: %d video pts: %f", out_size, video_pts);	raw_picture->pts++;	free(p_rotated_buffer);	if (out_size == -2) {		// network interrupted		call_void_method(env, thiz, "onVideoLiveDisconnected");	}}

int movie_picture_buffer::write(AVFrame* pFrame, double dPts){    movie_picture* pMoviePicture = nullptr;    std::unique_lock<std::mutex> picBufLock(mutex);    while(unsafe_full() && !aborting)    {        cond.wait(picBufLock);    }    picBufLock.unlock();    if(aborting) { return -1; }    pMoviePicture = &picture_queue[write_index];    std::unique_lock<std::mutex> pictureLock(pMoviePicture->mutex);    if(pMoviePicture->buffer)    {        sws_context = sws_getCachedContext(sws_context, pFrame->width, pFrame->height, (AVPixelFormat)pFrame->format, pMoviePicture->width, pMoviePicture->height, pMoviePicture->pixel_format, SWS_BICUBIC, nullptr, nullptr, nullptr);        if(sws_context == nullptr)        {            std::cerr << "Failed to initialize SwsContext/n";            return 1;        }        /* Allocate a new frame and buffer for the destination RGB24 data. */        AVFrame *pFrameRGB = av_frame_alloc();#if (defined(CORSIX_TH_USE_LIBAV) && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(54, 6, 0)) || /    (defined(CORSIX_TH_USE_FFMPEG) && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51, 63, 100))        av_image_fill_arrays(pFrameRGB->data, pFrameRGB->linesize, pMoviePicture->buffer, pMoviePicture->pixel_format, pMoviePicture->width, pMoviePicture->height, 1);#else        avpicture_fill((AVPicture *)pFrameRGB, pMoviePicture->buffer, pMoviePicture->pixel_format, pMoviePicture->width, pMoviePicture->height);#endif        /* Rescale the frame data and convert it to RGB24. */        sws_scale(sws_context, pFrame->data, pFrame->linesize, 0, pFrame->height, pFrameRGB->data, pFrameRGB->linesize);        av_frame_free(&pFrameRGB);        pMoviePicture->pts = dPts;        pictureLock.unlock();        write_index++;        if(write_index == picture_buffer_size)        {            write_index = 0;        }        picBufLock.lock();        picture_count++;        picBufLock.unlock();    }    return 0;}

static int vo_dx_vfmt2rgb(AVPicture * dst, AVPicture * src){    static struct SwsContext *img_convert_ctx;    img_convert_ctx = sws_getCachedContext(img_convert_ctx, dlpctxp->pwidth,                                           dlpctxp->pheight, dlpctxp->pixfmt, dlpctxp->pwidth, dlpctxp->pheight,                                           g_image_format, 0, NULL, NULL, NULL);    sws_scale(img_convert_ctx, src->data, src->linesize, 0, dlpctxp->pheight,              dst->data, dst->linesize);    return 0;}

int video_scaler_create(video_scaler_t **scaler_out,		const struct video_scale_info *dst,		const struct video_scale_info *src,		enum video_scale_type type){	enum AVPixelFormat format_src = get_ffmpeg_video_format(src->format);	enum AVPixelFormat format_dst = get_ffmpeg_video_format(dst->format);	int                scale_type = get_ffmpeg_scale_type(type);	const int          *coeff_src = get_ffmpeg_coeffs(src->colorspace);	const int          *coeff_dst = get_ffmpeg_coeffs(dst->colorspace);	int                range_src  = get_ffmpeg_range_type(src->range);	int                range_dst  = get_ffmpeg_range_type(dst->range);	struct video_scaler *scaler;	int ret;	if (!scaler_out)		return VIDEO_SCALER_FAILED;	if (format_src == AV_PIX_FMT_NONE ||	    format_dst == AV_PIX_FMT_NONE)		return VIDEO_SCALER_BAD_CONVERSION;	scaler = bzalloc(sizeof(struct video_scaler));	scaler->src_height = src->height;	scaler->swscale = sws_getCachedContext(NULL,			src->width, src->height, format_src,			dst->width, dst->height, format_dst,			scale_type, NULL, NULL, NULL);	if (!scaler->swscale) {		blog(LOG_ERROR, "video_scaler_create: Could not create "		                "swscale");		goto fail;	}	ret = sws_setColorspaceDetails(scaler->swscale,			coeff_src, range_src,			coeff_dst, range_dst,			0, FIXED_1_0, FIXED_1_0);	if (ret < 0) {		blog(LOG_DEBUG, "video_scaler_create: "		                "sws_setColorspaceDetails failed, ignoring");	}	*scaler_out = scaler;	return VIDEO_SCALER_SUCCESS;fail:	video_scaler_destroy(scaler);	return VIDEO_SCALER_FAILED;}

bool FFMpegVideoDecoderPriv::readFrame( int frame ){	AVPacket packet;	int frameFinished;	while ( m_currentFrameNumber < frame )	{		// Read a frame		if ( av_read_frame( pFormatCtx, &packet ) < 0 )			return false;  // Frame read failed (e.g. end of stream)		if ( packet.stream_index == videoStream )		{			// Is this a packet from the video stream -> decode video frame			avcodec_decode_video2( pCodecCtx, pFrame, &frameFinished, &packet );			// Did we get a video frame?			if ( frameFinished )			{				m_currentFrameNumber++;				if ( m_currentFrameNumber >= frame )				{					int w = pCodecCtx->width;					int h = pCodecCtx->height;					img_convert_ctx = sws_getCachedContext(img_convert_ctx,w, h, pCodecCtx->pix_fmt, w, h, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);					if ( img_convert_ctx == NULL )					{						printf("Cannot initialize the conversion context!/n");						return false;					}					sws_scale( img_convert_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize );					// Convert the frame to QImage					m_currentFrameImage = QImage( w, h, QImage::Format_RGB888 );					for ( int y = 0; y < h; y++ )						memcpy( m_currentFrameImage.scanLine(y), pFrameRGB->data[0] + y * pFrameRGB->linesize[0], w*3 );				}			}		}		av_free_packet( &packet );	}	return true;}

static int DecodeFrame(const char* lpszOutFileName, AVCodecContext* pDecCtx,                        AVFrame* pFrame,  AVFrame* pFrameRGB, int* pnFrameCount, AVPacket* pAVPacket, int bLastFrame) {     int nGotFrame = 0;     int nLen = avcodec_decode_video2(pDecCtx, pFrame, &nGotFrame, pAVPacket);     if (nLen < 0) {         fprintf(stderr, "Error while decoding frame %d/n", *pnFrameCount);         return nLen;     }     if (nGotFrame) {         printf("Saving %sframe %3d/n", bLastFrame ? "last " : "", *pnFrameCount);         fflush(stdout); #if 0        char buf[1024];        /* the picture is allocated by the decoder, no need to free it */         snprintf(buf, sizeof(buf), outfilename, *pnFrameCount);         SavePGM(pFrame->data[0], pFrame->linesize[0], pDecCtx->width, pDecCtx->height, buf); #else        //yuv420p to rgb        if (pFrameBuffer == NULL) {            int numBytes = avpicture_get_size(PIX_FMT_RGB24, pDecCtx->width, pDecCtx->height);            pFrameBuffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));            avpicture_fill((AVPicture *)pFrameRGB, pFrameBuffer, PIX_FMT_RGB24, pDecCtx->width, pDecCtx->height);        }        SwsContext* pImgConvertCtx = NULL;        pImgConvertCtx = sws_getCachedContext(pImgConvertCtx, pDecCtx->width, pDecCtx->height, pDecCtx->pix_fmt,            pDecCtx->width, pDecCtx->height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);        sws_scale(pImgConvertCtx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0,             pDecCtx->height, pFrameRGB->data, pFrameRGB->linesize);        //save to file        SavePPM(pFrameRGB, pDecCtx->width, pDecCtx->height, *pnFrameCount);        SaveYUV420P(pFrame, pDecCtx->width, pDecCtx->height, lpszOutFileName);#endif        (*pnFrameCount)++;     }    if (pAVPacket->data) {         pAVPacket->size -= nLen;         pAVPacket->data += nLen;     }     return 0; } 

JNIEXPORT jlong JNICALLJava_org_jitsi_impl_neomedia_codec_FFmpeg_sws_1getCachedContext    (JNIEnv *env, jclass clazz, jlong ctx, jint srcW, jint srcH,        jint srcFormat, jint dstW, jint dstH, jint dstFormat, jint flags){    return        (jlong) (intptr_t)            sws_getCachedContext(                (struct SwsContext *) (intptr_t) ctx,                (int) srcW, (int) srcH, (enum PixelFormat) srcFormat,                (int) dstW, (int) dstH, (enum PixelFormat) dstFormat,                (int) flags,                NULL, NULL, NULL);}