Attachment #468124 for bug #575230

View | Details | Raw Unified | Return to bug 575230
Collapse All | Expand All




#endif


FFMPEGLibrary::FFMPEGLibrary(AVCodecID codec)
{
  m_codec = codec;
  if (m_codec==CODEC_ID_H264)

  return true;
}

AVCodec *FFMPEGLibrary::AvcodecFindEncoder(enum AVCodecID id)
{
  return Favcodec_find_encoder(id);
}

AVCodec *FFMPEGLibrary::AvcodecFindDecoder(enum AVCodecID id)
{
  WaitAndSignal m(processLock);





class FFMPEGLibrary 
{
  public:
    FFMPEGLibrary(AVCodecID codec);
    ~FFMPEGLibrary();

    bool Load();

    AVCodec *AvcodecFindEncoder(enum AVCodecID id);
    AVCodec *AvcodecFindDecoder(enum AVCodecID id);
    AVCodecContext *AvcodecAllocContext(void);
    AVFrame *AvcodecAllocFrame(void);
    int AvcodecOpen(AVCodecContext *ctx, AVCodec *codec);

    DynaLink m_libAvcodec;
    DynaLink m_libAvutil;

    AVCodecID m_codec;
    char m_codecString[32];

    void (*Favcodec_init)(void);
    void (*Fav_init_packet)(AVPacket *pkt);

    void (*Favcodec_register_all)(void);
    AVCodec *(*Favcodec_find_encoder)(enum AVCodecID id);
    AVCodec *(*Favcodec_find_decoder)(enum AVCodecID id);
    AVCodecContext *(*Favcodec_alloc_context)(void);
    AVFrame *(*Favcodec_alloc_frame)(void);
    int (*Favcodec_open)(AVCodecContext *ctx, AVCodec *codec);




 * 1. no value of a existing codec ID changes (that would break ABI),
 * 2. it is as close as possible to similar codecs.
 */
enum AVCodecID {
    CODEC_ID_NONE,

    /* video codecs */


    char codec_name[32];
    enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
    enum AVCodecID codec_id; /* see CODEC_ID_xxx */

    /**
     * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

     */
    const char *name;
    enum AVMediaType type;
    enum AVCodecID id;
    int priv_data_size;
    int (*init)(AVCodecContext *);
    int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data);

     *
     * See CODEC_ID_xxx
     */
    enum AVCodecID id;

    /**
     * Supported pixel format.

/**
 * Find a registered encoder with a matching codec ID.
 *
 * @param id AVCodecID of the requested encoder
 * @return An encoder if one was found, NULL otherwise.
 */
AVCodec *avcodec_find_encoder(enum AVCodecID id);

/**
 * Find a registered encoder with the specified name.

/**
 * Find a registered decoder with a matching codec ID.
 *
 * @param id AVCodecID of the requested decoder
 * @return A decoder if one was found, NULL otherwise.
 */
AVCodec *avcodec_find_decoder(enum AVCodecID id);

/**
 * Find a registered decoder with the specified name.

 * @param[in] codec_id the codec
 * @return Number of bits per sample or zero if unknown for the given codec.
 */
int av_get_bits_per_sample(enum AVCodecID codec_id);

#if FF_API_OLD_SAMPLE_FMT
/**

Lines 48-53 Link Here

(-)opal-3.10.10.orig/plugins/video/H.263-1998/h263-1998.cxx (-22 / +17 lines)
48	#endif	48	#endif
49		49
50	#include "h263-1998.h"	50	#include "h263-1998.h"
		51	extern "C"
		52	{
		53	#include <libavutil/opt.h>
		54	}
51	#include <limits>	55	#include <limits>
52	#include <iomanip>	56	#include <iomanip>
53	#include <stdio.h>	57	#include <stdio.h>
Lines 203-209 Link Here
203	PTRACE(4, m_prefix, "Encoder closed");	207	PTRACE(4, m_prefix, "Encoder closed");
204	}	208	}
205		209
206	bool H263_Base_EncoderContext::Init(CodecID codecId)	210	bool H263_Base_EncoderContext::Init(AVCodecID codecId)
207	{	211	{
208	PTRACE(5, m_prefix, "Opening encoder");	212	PTRACE(5, m_prefix, "Opening encoder");
209		213
Lines 317-325 Link Here
317	// Level 2+	321	// Level 2+
318	// works with eyeBeam, signaled via non-standard "D"	322	// works with eyeBeam, signaled via non-standard "D"
319	if (atoi(value) == 1)	323	if (atoi(value) == 1)
320	m_context->flags \|= CODEC_FLAG_H263P_UMV;	324	av_opt_set_int(m_context->priv_data, "umv", 1, 0);
321	else	325	else
322	m_context->flags &= ~CODEC_FLAG_H263P_UMV;	326	av_opt_set_int(m_context->priv_data, "umv", 0, 0);
323	return;	327	return;
324	}	328	}
325		329
Lines 328-336 Link Here
328	// Annex F: Advanced Prediction Mode	332	// Annex F: Advanced Prediction Mode
329	// does not work with eyeBeam	333	// does not work with eyeBeam
330	if (atoi(value) == 1)	334	if (atoi(value) == 1)
331	m_context->flags \|= CODEC_FLAG_OBMC;	335	av_opt_set_int(m_context->priv_data, "obmc", 1, 0);
332	else	336	else
333	m_context->flags &= ~CODEC_FLAG_OBMC;	337	av_opt_set_int(m_context->priv_data, "obmc", 0, 0);
334	return;	338	return;
335	}	339	}
336	#endif	340	#endif
Lines 360-368 Link Here
360	// Annex K: Slice Structure	364	// Annex K: Slice Structure
361	// does not work with eyeBeam	365	// does not work with eyeBeam
362	if (atoi(value) != 0)	366	if (atoi(value) != 0)
363	m_context->flags \|= CODEC_FLAG_H263P_SLICE_STRUCT;	367	av_opt_set_int(m_context->priv_data, "structured_slices", 1, 0);
364	else	368	else
365	m_context->flags &= ~CODEC_FLAG_H263P_SLICE_STRUCT;	369	av_opt_set_int(m_context->priv_data, "structured_slices", 0, 0);
366	return;	370	return;
367	}	371	}
368		372
Lines 370-378 Link Here
370	// Annex S: Alternative INTER VLC mode	374	// Annex S: Alternative INTER VLC mode
371	// does not work with eyeBeam	375	// does not work with eyeBeam
372	if (atoi(value) == 1)	376	if (atoi(value) == 1)
373	m_context->flags \|= CODEC_FLAG_H263P_AIV;	377	av_opt_set_int(m_context->priv_data, "aiv", 1, 0);
374	else	378	else
375	m_context->flags &= ~CODEC_FLAG_H263P_AIV;	379	av_opt_set_int(m_context->priv_data, "aiv", 0, 0);
376	return;	380	return;
377	}	381	}
378		382
Lines 450-464 Link Here
450	PTRACE(5, m_prefix, "qmax set to " << m_context->qmax);	454	PTRACE(5, m_prefix, "qmax set to " << m_context->qmax);
451	PTRACE(5, m_prefix, "payload size set to " << m_context->rtp_payload_size);	455	PTRACE(5, m_prefix, "payload size set to " << m_context->rtp_payload_size);
452		456
453	#define CODEC_TRACER_FLAG(tracer, flag) \
454	PTRACE(4, m_prefix, #flag " is " << ((m_context->flags & flag) ? "enabled" : "disabled"));
455	CODEC_TRACER_FLAG(tracer, CODEC_FLAG_H263P_UMV);
456	CODEC_TRACER_FLAG(tracer, CODEC_FLAG_OBMC);
457	CODEC_TRACER_FLAG(tracer, CODEC_FLAG_AC_PRED);
458	CODEC_TRACER_FLAG(tracer, CODEC_FLAG_H263P_SLICE_STRUCT)
459	CODEC_TRACER_FLAG(tracer, CODEC_FLAG_LOOP_FILTER);
460	CODEC_TRACER_FLAG(tracer, CODEC_FLAG_H263P_AIV);
461
462	return FFMPEGLibraryInstance.AvcodecOpen(m_context, m_codec) == 0;	457	return FFMPEGLibraryInstance.AvcodecOpen(m_context, m_codec) == 0;
463	}	458	}
464		459
Lines 521-527 Link Here
521		516
522	// Need to copy to local buffer to guarantee 16 byte alignment	517	// Need to copy to local buffer to guarantee 16 byte alignment
523	memcpy(m_inputFrame->data[0], OPAL_VIDEO_FRAME_DATA_PTR(header), header->widthheader->height3/2);	518	memcpy(m_inputFrame->data[0], OPAL_VIDEO_FRAME_DATA_PTR(header), header->widthheader->height3/2);
524	m_inputFrame->pict_type = (flags & PluginCodec_CoderForceIFrame) ? FF_I_TYPE : AV_PICTURE_TYPE_NONE;	519	m_inputFrame->pict_type = (flags & PluginCodec_CoderForceIFrame) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_NONE;
525		520
526	/*	521	/*
527	m_inputFrame->pts = (int64_t)srcRTP.GetTimestamp()*m_context->time_base.den/m_context->time_base.num/VIDEO_CLOCKRATE;	522	m_inputFrame->pts = (int64_t)srcRTP.GetTimestamp()*m_context->time_base.den/m_context->time_base.num/VIDEO_CLOCKRATE;
Lines 603-615 Link Here
603	m_context->rtp_callback = &H263_RFC2190_EncoderContext::RTPCallBack;	598	m_context->rtp_callback = &H263_RFC2190_EncoderContext::RTPCallBack;
604	m_context->opaque = this; // used to separate out packets from different encode threads	599	m_context->opaque = this; // used to separate out packets from different encode threads
605		600
606	m_context->flags &= ~CODEC_FLAG_H263P_UMV;	601	av_opt_set_int(m_context->priv_data, "umv", 0, 0);
607	m_context->flags &= ~CODEC_FLAG_4MV;	602	m_context->flags &= ~CODEC_FLAG_4MV;
608	#if LIBAVCODEC_RTP_MODE	603	#if LIBAVCODEC_RTP_MODE
609	m_context->flags &= ~CODEC_FLAG_H263P_AIC;	604	m_context->flags &= ~CODEC_FLAG_H263P_AIC;
610	#endif	605	#endif
611	m_context->flags &= ~CODEC_FLAG_H263P_AIV;	606	av_opt_set_int(m_context->priv_data, "aiv", 0, 0);
612	m_context->flags &= ~CODEC_FLAG_H263P_SLICE_STRUCT;	607	av_opt_set_int(m_context->priv_data, "structured_slices", 0, 0);
613		608
614	return true;	609	return true;
615	}	610	}

Lines 115-121 Link Here

(-)opal-3.10.10.orig/plugins/video/H.263-1998/h263-1998.h (-1 / +1 lines)
115	virtual ~H263_Base_EncoderContext();	115	virtual ~H263_Base_EncoderContext();
116		116
117	virtual bool Init() = 0;	117	virtual bool Init() = 0;
118	virtual bool Init(CodecID codecId);	118	virtual bool Init(AVCodecID codecId);
119		119
120	virtual bool SetOptions(const char * const * options);	120	virtual bool SetOptions(const char * const * options);
121	virtual void SetOption(const char * option, const char * value);	121	virtual void SetOption(const char * option, const char * value);

Lines 35-41 Link Here

(-)opal-3.10.10.orig/plugins/video/H.263-1998/Makefile.in (-1 / +1 lines)
35	$(COMMONDIR)/dyna.cxx	35	$(COMMONDIR)/dyna.cxx
36		36
37	CFLAGS += @LIBAVCODEC_CFLAGS@ -I$(COMMONDIR)	37	CFLAGS += @LIBAVCODEC_CFLAGS@ -I$(COMMONDIR)
38	LIBS += @DL_LIBS@	38	LIBS += @DL_LIBS@ @LIBAVUTIL_LIBS@
39		39
40	HAVE_LIBAVCODEC_RTP_MODE=@HAVE_LIBAVCODEC_RTP_MODE@	40	HAVE_LIBAVCODEC_RTP_MODE=@HAVE_LIBAVCODEC_RTP_MODE@
41	ifeq ($(HAVE_LIBAVCODEC_RTP_MODE),yes)	41	ifeq ($(HAVE_LIBAVCODEC_RTP_MODE),yes)

Lines 27-32 Link Here

(-)opal-3.10.10.orig/plugins/video/H.264/gpl/h264_helper.cxx (+1 lines)
27	#include <fstream>	27	#include <fstream>
28	#include <stdlib.h>	28	#include <stdlib.h>
29	#include <sys/stat.h>	29	#include <sys/stat.h>
		30	#include <unistd.h>
30		31
31	#ifdef HAVE_UNISTD_H	32	#ifdef HAVE_UNISTD_H
32	#include <unistd.h>	33	#include <unistd.h>




#include "plugin-config.h"
#endif

#define FF_IDCT_H264 11
#define CODEC_FLAG2_SKIP_RD 0x00004000

#include <codec/opalplugin.hpp>

#include "../common/ffmpeg.h"

        return false;

      m_context->workaround_bugs = FF_BUG_AUTODETECT;
      m_context->error_recognition = FF_ER_AGGRESSIVE;
      m_context->idct_algo = FF_IDCT_H264;
      m_context->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
      m_context->flags = CODEC_FLAG_INPUT_PRESERVED | CODEC_FLAG_EMU_EDGE;
      m_context->flags2 = CODEC_FLAG2_DROP_FRAME_TIMECODE |
                          CODEC_FLAG2_MEMC_ONLY |
                          CODEC_FLAG2_DROP_FRAME_TIMECODE |
                          CODEC_FLAG2_SKIP_RD |
                          CODEC_FLAG2_CHUNKS;


Lines 33-38 Link Here

(-)opal-3.10.10.orig/plugins/video/H.264/shared/x264wrap.cxx (+1 lines)
33		33
34	#include <codec/opalplugin.hpp>	34	#include <codec/opalplugin.hpp>
35	#include <stdio.h>	35	#include <stdio.h>
		36	#include <unistd.h>
36		37
37	#ifdef HAVE_UNISTD_H	38	#ifdef HAVE_UNISTD_H
38	#include <unistd.h>	39	#include <unistd.h>

Lines 31-37 Link Here

(-)opal-3.10.10.orig/plugins/video/MPEG4-ffmpeg/Makefile.in (-1 / +1 lines)
31	SRCS := mpeg4.cxx $(COMMONDIR)/dyna.cxx	31	SRCS := mpeg4.cxx $(COMMONDIR)/dyna.cxx
32		32
33	CFLAGS += @LIBAVCODEC_CFLAGS@ -I$(COMMONDIR)	33	CFLAGS += @LIBAVCODEC_CFLAGS@ -I$(COMMONDIR)
34	LIBS += @DL_LIBS@	34	LIBS += @DL_LIBS@ @LIBAVUTIL_LIBS@
35		35
36	# Add LIBAVCODEC_SOURCE_DIR to the include path so we can #include <libavcodec/...h>	36	# Add LIBAVCODEC_SOURCE_DIR to the include path so we can #include <libavcodec/...h>
37	# Also add libavutil, so ffmpeg headers can #include "log.h".	37	# Also add libavutil, so ffmpeg headers can #include "log.h".





#else /* LIBAVCODEC_HAVE_SOURCE_DIR */
#include "../common/ffmpeg.h"
#include <libavutil/opt.h>
#endif /* LIBAVCODEC_HAVE_SOURCE_DIR */
}


    m_avpicture->quality = m_videoQMin;

#ifdef USE_ORIG
    av_opt_set_int(m_avcontext->priv_data, "data_partitionin", 1, 0);
    m_avcontext->flags |= CODEC_FLAG_4MV;    // 4 motion vectors
#else
    m_avcontext->max_b_frames=0; /*don't use b frames*/
    m_avcontext->flags|=CODEC_FLAG_AC_PRED;
    av_opt_set_int(m_avcontext->priv_data, "umv", 1, 0);
    /*c->flags|=CODEC_FLAG_QPEL;*/ /*don't enable this one: this forces profile_level to advanced simple profile */
    m_avcontext->flags|=CODEC_FLAG_4MV;
    m_avcontext->flags|=CODEC_FLAG_GMC;
    m_avcontext->flags|=CODEC_FLAG_LOOP_FILTER;
    av_opt_set_int(m_avcontext->priv_data, "structured_slices", 1, 0);
#endif
    m_avcontext->opaque = this;              // for use in RTP callback
}

        // Should the next frame be an I-Frame?
        if ((flags & PluginCodec_CoderForceIFrame) || (m_frameNum == 0))
        {
            m_avpicture->pict_type = AV_PICTURE_TYPE_I;
        }
        else // No IFrame requested, let avcodec decide what to do
        {


void MPEG4DecoderContext::SetStaticDecodingParams() {
    m_avcontext->flags |= CODEC_FLAG_4MV; 
    av_opt_set_int(m_avcontext->priv_data, "data_partitionin", 1, 0);
    m_avcontext->workaround_bugs = 0; // no workaround for buggy implementations
}


Return to bug 575230

Lines 210-216 Link Here

(-)opal-3.10.10.orig/plugins/video/common/dyna.cxx (-3 / +3 lines)
210	#endif	210	#endif
211		211
212		212
213	FFMPEGLibrary::FFMPEGLibrary(CodecID codec)	213	FFMPEGLibrary::FFMPEGLibrary(AVCodecID codec)
214	{	214	{
215	m_codec = codec;	215	m_codec = codec;
216	if (m_codec==CODEC_ID_H264)	216	if (m_codec==CODEC_ID_H264)
Lines 348-359 Link Here
348	return true;	348	return true;
349	}	349	}
350		350
351	AVCodec *FFMPEGLibrary::AvcodecFindEncoder(enum CodecID id)	351	AVCodec *FFMPEGLibrary::AvcodecFindEncoder(enum AVCodecID id)
352	{	352	{
353	return Favcodec_find_encoder(id);	353	return Favcodec_find_encoder(id);
354	}	354	}
355		355
356	AVCodec *FFMPEGLibrary::AvcodecFindDecoder(enum CodecID id)	356	AVCodec *FFMPEGLibrary::AvcodecFindDecoder(enum AVCodecID id)
357	{	357	{
358	WaitAndSignal m(processLock);	358	WaitAndSignal m(processLock);
359		359

Lines 101-107 Link Here

(-)opal-3.10.10.orig/plugins/video/common/ffmpeg/libavcodec/avcodec.h (-9 / +9 lines)
101	* 1. no value of a existing codec ID changes (that would break ABI),	101	* 1. no value of a existing codec ID changes (that would break ABI),
102	* 2. it is as close as possible to similar codecs.	102	* 2. it is as close as possible to similar codecs.
103	*/	103	*/
104	enum CodecID {	104	enum AVCodecID {
105	CODEC_ID_NONE,	105	CODEC_ID_NONE,
106		106
107	/* video codecs */	107	/* video codecs */
Lines 1390-1396 Link Here
1390		1390
1391	char codec_name[32];	1391	char codec_name[32];
1392	enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */	1392	enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
1393	enum CodecID codec_id; /* see CODEC_ID_xxx */	1393	enum AVCodecID codec_id; /* see CODEC_ID_xxx */
1394		1394
1395	/**	1395	/**
1396	* fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').	1396	* fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Lines 2843-2849 Link Here
2843	*/	2843	*/
2844	const char *name;	2844	const char *name;
2845	enum AVMediaType type;	2845	enum AVMediaType type;
2846	enum CodecID id;	2846	enum AVCodecID id;
2847	int priv_data_size;	2847	int priv_data_size;
2848	int (init)(AVCodecContext );	2848	int (init)(AVCodecContext );
2849	int (encode)(AVCodecContext , uint8_t buf, int buf_size, void data);	2849	int (encode)(AVCodecContext , uint8_t buf, int buf_size, void data);
Lines 2898-2904 Link Here
2898	*	2898	*
2899	* See CODEC_ID_xxx	2899	* See CODEC_ID_xxx
2900	*/	2900	*/
2901	enum CodecID id;	2901	enum AVCodecID id;
2902		2902
2903	/**	2903	/**
2904	* Supported pixel format.	2904	* Supported pixel format.
Lines 3402-3411 Link Here
3402	/**	3402	/**
3403	* Find a registered encoder with a matching codec ID.	3403	* Find a registered encoder with a matching codec ID.
3404	*	3404	*
3405	* @param id CodecID of the requested encoder	3405	* @param id AVCodecID of the requested encoder
3406	* @return An encoder if one was found, NULL otherwise.	3406	* @return An encoder if one was found, NULL otherwise.
3407	*/	3407	*/
3408	AVCodec *avcodec_find_encoder(enum CodecID id);	3408	AVCodec *avcodec_find_encoder(enum AVCodecID id);
3409		3409
3410	/**	3410	/**
3411	* Find a registered encoder with the specified name.	3411	* Find a registered encoder with the specified name.
Lines 3418-3427 Link Here
3418	/**	3418	/**
3419	* Find a registered decoder with a matching codec ID.	3419	* Find a registered decoder with a matching codec ID.
3420	*	3420	*
3421	* @param id CodecID of the requested decoder	3421	* @param id AVCodecID of the requested decoder
3422	* @return A decoder if one was found, NULL otherwise.	3422	* @return A decoder if one was found, NULL otherwise.
3423	*/	3423	*/
3424	AVCodec *avcodec_find_decoder(enum CodecID id);	3424	AVCodec *avcodec_find_decoder(enum AVCodecID id);
3425		3425
3426	/**	3426	/**
3427	* Find a registered decoder with the specified name.	3427	* Find a registered decoder with the specified name.
Lines 3822-3828 Link Here
3822	* @param[in] codec_id the codec	3822	* @param[in] codec_id the codec
3823	* @return Number of bits per sample or zero if unknown for the given codec.	3823	* @return Number of bits per sample or zero if unknown for the given codec.
3824	*/	3824	*/
3825	int av_get_bits_per_sample(enum CodecID codec_id);	3825	int av_get_bits_per_sample(enum AVCodecID codec_id);
3826		3826
3827	#if FF_API_OLD_SAMPLE_FMT	3827	#if FF_API_OLD_SAMPLE_FMT
3828	/**	3828	/**

Lines 103-108 Link Here

(-)opal-3.10.10.orig/plugins/video/MPEG4-ffmpeg/mpeg4.cxx (-5 / +6 lines)
103		103
104	#else /* LIBAVCODEC_HAVE_SOURCE_DIR */	104	#else /* LIBAVCODEC_HAVE_SOURCE_DIR */
105	#include "../common/ffmpeg.h"	105	#include "../common/ffmpeg.h"
		106	#include <libavutil/opt.h>
106	#endif /* LIBAVCODEC_HAVE_SOURCE_DIR */	107	#endif /* LIBAVCODEC_HAVE_SOURCE_DIR */
107	}	108	}
108		109
Lines 589-605 Link Here
589	m_avpicture->quality = m_videoQMin;	590	m_avpicture->quality = m_videoQMin;
590		591
591	#ifdef USE_ORIG	592	#ifdef USE_ORIG
592	m_avcontext->flags \|= CODEC_FLAG_PART; // data partitioning	593	av_opt_set_int(m_avcontext->priv_data, "data_partitionin", 1, 0);
593	m_avcontext->flags \|= CODEC_FLAG_4MV; // 4 motion vectors	594	m_avcontext->flags \|= CODEC_FLAG_4MV; // 4 motion vectors
594	#else	595	#else
595	m_avcontext->max_b_frames=0; /don't use b frames/	596	m_avcontext->max_b_frames=0; /don't use b frames/
596	m_avcontext->flags\|=CODEC_FLAG_AC_PRED;	597	m_avcontext->flags\|=CODEC_FLAG_AC_PRED;
597	m_avcontext->flags\|=CODEC_FLAG_H263P_UMV;	598	av_opt_set_int(m_avcontext->priv_data, "umv", 1, 0);
598	/c->flags\|=CODEC_FLAG_QPEL;/ /don't enable this one: this forces profile_level to advanced simple profile /	599	/c->flags\|=CODEC_FLAG_QPEL;/ /don't enable this one: this forces profile_level to advanced simple profile /
599	m_avcontext->flags\|=CODEC_FLAG_4MV;	600	m_avcontext->flags\|=CODEC_FLAG_4MV;
600	m_avcontext->flags\|=CODEC_FLAG_GMC;	601	m_avcontext->flags\|=CODEC_FLAG_GMC;
601	m_avcontext->flags\|=CODEC_FLAG_LOOP_FILTER;	602	m_avcontext->flags\|=CODEC_FLAG_LOOP_FILTER;
602	m_avcontext->flags\|=CODEC_FLAG_H263P_SLICE_STRUCT;	603	av_opt_set_int(m_avcontext->priv_data, "structured_slices", 1, 0);
603	#endif	604	#endif
604	m_avcontext->opaque = this; // for use in RTP callback	605	m_avcontext->opaque = this; // for use in RTP callback
605	}	606	}
Lines 804-810 Link Here
804	// Should the next frame be an I-Frame?	805	// Should the next frame be an I-Frame?
805	if ((flags & PluginCodec_CoderForceIFrame) \|\| (m_frameNum == 0))	806	if ((flags & PluginCodec_CoderForceIFrame) \|\| (m_frameNum == 0))
806	{	807	{
807	m_avpicture->pict_type = FF_I_TYPE;	808	m_avpicture->pict_type = AV_PICTURE_TYPE_I;
808	}	809	}
809	else // No IFrame requested, let avcodec decide what to do	810	else // No IFrame requested, let avcodec decide what to do
810	{	811	{
Lines 1325-1331 Link Here
1325		1326
1326	void MPEG4DecoderContext::SetStaticDecodingParams() {	1327	void MPEG4DecoderContext::SetStaticDecodingParams() {
1327	m_avcontext->flags \|= CODEC_FLAG_4MV;	1328	m_avcontext->flags \|= CODEC_FLAG_4MV;
1328	m_avcontext->flags \|= CODEC_FLAG_PART;	1329	av_opt_set_int(m_avcontext->priv_data, "data_partitionin", 1, 0);
1329	m_avcontext->workaround_bugs = 0; // no workaround for buggy implementations	1330	m_avcontext->workaround_bugs = 0; // no workaround for buggy implementations
1330	}	1331	}
1331		1332

Lines 88-100 Link Here

(-)opal-3.10.10.orig/plugins/video/common/dyna.h (-6 / +6 lines)
88	class FFMPEGLibrary	88	class FFMPEGLibrary
89	{	89	{
90	public:	90	public:
91	FFMPEGLibrary(CodecID codec);	91	FFMPEGLibrary(AVCodecID codec);
92	~FFMPEGLibrary();	92	~FFMPEGLibrary();
93		93
94	bool Load();	94	bool Load();
95		95
96	AVCodec *AvcodecFindEncoder(enum CodecID id);	96	AVCodec *AvcodecFindEncoder(enum AVCodecID id);
97	AVCodec *AvcodecFindDecoder(enum CodecID id);	97	AVCodec *AvcodecFindDecoder(enum AVCodecID id);
98	AVCodecContext *AvcodecAllocContext(void);	98	AVCodecContext *AvcodecAllocContext(void);
99	AVFrame *AvcodecAllocFrame(void);	99	AVFrame *AvcodecAllocFrame(void);
100	int AvcodecOpen(AVCodecContext ctx, AVCodec codec);	100	int AvcodecOpen(AVCodecContext ctx, AVCodec codec);
Lines 117-131 Link Here
117	DynaLink m_libAvcodec;	117	DynaLink m_libAvcodec;
118	DynaLink m_libAvutil;	118	DynaLink m_libAvutil;
119		119
120	CodecID m_codec;	120	AVCodecID m_codec;
121	char m_codecString[32];	121	char m_codecString[32];
122		122
123	void (*Favcodec_init)(void);	123	void (*Favcodec_init)(void);
124	void (Fav_init_packet)(AVPacket pkt);	124	void (Fav_init_packet)(AVPacket pkt);
125		125
126	void (*Favcodec_register_all)(void);	126	void (*Favcodec_register_all)(void);
127	AVCodec (Favcodec_find_encoder)(enum CodecID id);	127	AVCodec (Favcodec_find_encoder)(enum AVCodecID id);
128	AVCodec (Favcodec_find_decoder)(enum CodecID id);	128	AVCodec (Favcodec_find_decoder)(enum AVCodecID id);
129	AVCodecContext (Favcodec_alloc_context)(void);	129	AVCodecContext (Favcodec_alloc_context)(void);
130	AVFrame (Favcodec_alloc_frame)(void);	130	AVFrame (Favcodec_alloc_frame)(void);
131	int (Favcodec_open)(AVCodecContext ctx, AVCodec *codec);	131	int (Favcodec_open)(AVCodecContext ctx, AVCodec *codec);

Lines 40-45 Link Here

(-)opal-3.10.10.orig/plugins/video/H.264/h264-x264.cxx (-4 / +4 lines)
40	#include "plugin-config.h"	40	#include "plugin-config.h"
41	#endif	41	#endif
42		42
		43	#define FF_IDCT_H264 11
		44	#define CODEC_FLAG2_SKIP_RD 0x00004000
		45
43	#include <codec/opalplugin.hpp>	46	#include <codec/opalplugin.hpp>
44		47
45	#include "../common/ffmpeg.h"	48	#include "../common/ffmpeg.h"
Lines 1071-1083 Link Here
1071	return false;	1074	return false;
1072		1075
1073	m_context->workaround_bugs = FF_BUG_AUTODETECT;	1076	m_context->workaround_bugs = FF_BUG_AUTODETECT;
1074	m_context->error_recognition = FF_ER_AGGRESSIVE;
1075	m_context->idct_algo = FF_IDCT_H264;	1077	m_context->idct_algo = FF_IDCT_H264;
1076	m_context->error_concealment = FF_EC_GUESS_MVS \| FF_EC_DEBLOCK;	1078	m_context->error_concealment = FF_EC_GUESS_MVS \| FF_EC_DEBLOCK;
1077	m_context->flags = CODEC_FLAG_INPUT_PRESERVED \| CODEC_FLAG_EMU_EDGE;	1079	m_context->flags = CODEC_FLAG_INPUT_PRESERVED \| CODEC_FLAG_EMU_EDGE;
1078	m_context->flags2 = CODEC_FLAG2_BRDO \|	1080	m_context->flags2 = CODEC_FLAG2_DROP_FRAME_TIMECODE \|
1079	CODEC_FLAG2_MEMC_ONLY \|
1080	CODEC_FLAG2_DROP_FRAME_TIMECODE \|
1081	CODEC_FLAG2_SKIP_RD \|	1081	CODEC_FLAG2_SKIP_RD \|
1082	CODEC_FLAG2_CHUNKS;	1082	CODEC_FLAG2_CHUNKS;
1083		1083