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

// position pointer in file, position in secondAVFrame *VideoFFmpeg::grabFrame(long position){	AVPacket packet;	int frameFinished;	int posFound = 1;	bool frameLoaded = false;	int64_t targetTs = 0;	CacheFrame *frame;	int64_t dts = 0;	if (m_cacheStarted)	{		// when cache is active, we must not read the file directly		do {			pthread_mutex_lock(&m_cacheMutex);			frame = (CacheFrame *)m_frameCacheBase.first;			pthread_mutex_unlock(&m_cacheMutex);			// no need to remove the frame from the queue: the cache thread does not touch the head, only the tail			if (frame == NULL)			{				// no frame in cache, in case of file it is an abnormal situation				if (m_isFile)				{					// go back to no threaded reading					stopCache();					break;				}				return NULL;			}			if (frame->framePosition == -1) 			{				// this frame mark the end of the file (only used for file)				// leave in cache to make sure we don't miss it				m_eof = true;				return NULL;			}			// for streaming, always return the next frame, 			// that's what grabFrame does in non cache mode anyway.			if (m_isStreaming || frame->framePosition == position)			{				return frame->frame;			}			// for cam, skip old frames to keep image realtime.			// There should be no risk of clock drift since it all happens on the same CPU			if (frame->framePosition > position) 			{				// this can happen after rewind if the seek didn't find the first frame				// the frame in the buffer is ahead of time, just leave it there				return NULL;			}			// this frame is not useful, release it			pthread_mutex_lock(&m_cacheMutex);			BLI_remlink(&m_frameCacheBase, frame);			BLI_addtail(&m_frameCacheFree, frame);			pthread_mutex_unlock(&m_cacheMutex);		} while (true);	}	double timeBase = av_q2d(m_formatCtx->streams[m_videoStream]->time_base);	int64_t startTs = m_formatCtx->streams[m_videoStream]->start_time;	if (startTs == AV_NOPTS_VALUE)		startTs = 0;	// come here when there is no cache or cache has been stopped	// locate the frame, by seeking if necessary (seeking is only possible for files)	if (m_isFile)	{		// first check if the position that we are looking for is in the preseek range		// if so, just read the frame until we get there		if (position > m_curPosition + 1 			&& m_preseek 			&& position - (m_curPosition + 1) < m_preseek) 		{			while (av_read_frame(m_formatCtx, &packet)>=0)			{				if (packet.stream_index == m_videoStream) 				{					avcodec_decode_video2(						m_codecCtx, 						m_frame, &frameFinished, 						&packet);					if (frameFinished)					{						m_curPosition = (long)((packet.dts-startTs) * (m_baseFrameRate*timeBase) + 0.5);					}				}				av_free_packet(&packet);				if (position == m_curPosition+1)					break;			}		}		// if the position is not in preseek, do a direct jump		if (position != m_curPosition + 1) 		{ 			int64_t pos = (int64_t)((position - m_preseek) / (m_baseFrameRate*timeBase));			if (pos < 0)				pos = 0;			pos += startTs;//.........这里部分代码省略.........

static void init_iconfile_list(struct ListBase *list){	IconFile *ifile;	struct direntry *dir;	int totfile, i, index = 1;	const char *icondir;	BLI_listbase_clear(list);	icondir = BLI_get_folder(BLENDER_DATAFILES, "icons");	if (icondir == NULL)		return;		totfile = BLI_dir_contents(icondir, &dir);	for (i = 0; i < totfile; i++) {		if ((dir[i].type & S_IFREG)) {			const char *filename = dir[i].relname;						if (BLI_testextensie(filename, ".png")) {				/* loading all icons on file start is overkill & slows startup				 * its possible they change size after blender load anyway. */#if 0				int ifilex, ifiley;				char iconfilestr[FILE_MAX + 16]; /* allow 256 chars for file+dir */				ImBuf *bbuf = NULL;				/* check to see if the image is the right size, continue if not */				/* copying strings here should go ok, assuming that we never get back				 * a complete path to file longer than 256 chars */				BLI_join_dirfile(iconfilestr, sizeof(iconfilestr), icondir, filename);				bbuf = IMB_loadiffname(iconfilestr, IB_rect);				if (bbuf) {					ifilex = bbuf->x;					ifiley = bbuf->y;					IMB_freeImBuf(bbuf);				}				else {					ifilex = ifiley = 0;				}								/* bad size or failed to load */				if ((ifilex != ICON_IMAGE_W) || (ifiley != ICON_IMAGE_H)) {					printf("icon '%s' is wrong size %dx%d/n", iconfilestr, ifilex, ifiley);					continue;				}#endif          /* removed */				/* found a potential icon file, so make an entry for it in the cache list */				ifile = MEM_callocN(sizeof(IconFile), "IconFile");								BLI_strncpy(ifile->filename, filename, sizeof(ifile->filename));				ifile->index = index;				BLI_addtail(list, ifile);								index++;			}		}	}	BLI_free_filelist(dir, totfile);	dir = NULL;}

//.........这里部分代码省略.........					do_extrude = 2;				}			}						if (do_extrude) {				/* we re-use code for mirror editing... */				flipbone = NULL;				if (arm->flag & ARM_MIRROR_EDIT) {					flipbone = ED_armature_bone_get_mirrored(arm->edbo, ebone);					if (flipbone) {						forked = 0;  // we extrude 2 different bones						if (flipbone->flag & (BONE_TIPSEL | BONE_ROOTSEL | BONE_SELECTED))							/* don't want this bone to be selected... */							flipbone->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);					}					if ((flipbone == NULL) && (forked))						flipbone = ebone;				}								for (a = 0; a < 2; a++) {					if (a == 1) {						if (flipbone == NULL)							break;						else {							SWAP(EditBone *, flipbone, ebone);						}					}										totbone++;					newbone = MEM_callocN(sizeof(EditBone), "extrudebone");										if (do_extrude == true) {						copy_v3_v3(newbone->head, ebone->tail);						copy_v3_v3(newbone->tail, newbone->head);						newbone->parent = ebone;												newbone->flag = ebone->flag & (BONE_TIPSEL | BONE_RELATIVE_PARENTING);  // copies it, in case mirrored bone												if (newbone->parent) newbone->flag |= BONE_CONNECTED;					}					else {						copy_v3_v3(newbone->head, ebone->head);						copy_v3_v3(newbone->tail, ebone->head);						newbone->parent = ebone->parent;												newbone->flag = BONE_TIPSEL;												if (newbone->parent && (ebone->flag & BONE_CONNECTED)) {							newbone->flag |= BONE_CONNECTED;						}					}										newbone->weight = ebone->weight;					newbone->dist = ebone->dist;					newbone->xwidth = ebone->xwidth;					newbone->zwidth = ebone->zwidth;					newbone->ease1 = ebone->ease1;					newbone->ease2 = ebone->ease2;					newbone->rad_head = ebone->rad_tail; // don't copy entire bone...					newbone->rad_tail = ebone->rad_tail;					newbone->segments = 1;					newbone->layer = ebone->layer;										BLI_strncpy(newbone->name, ebone->name, sizeof(newbone->name));										if (flipbone && forked) {   // only set if mirror edit						if (strlen(newbone->name) < (MAXBONENAME - 2)) {							if (a == 0) strcat(newbone->name, "_L");							else strcat(newbone->name, "_R");						}					}					unique_editbone_name(arm->edbo, newbone->name, NULL);										/* Add the new bone to the list */					BLI_addtail(arm->edbo, newbone);					if (!first)						first = newbone;										/* restore ebone if we were flipping */					if (a == 1 && flipbone)						SWAP(EditBone *, flipbone, ebone);				}			}						/* Deselect the old bone */			ebone->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);		}	}	/* if only one bone, make this one active */	if (totbone == 1 && first) arm->act_edbone = first;	if (totbone == 0) return OPERATOR_CANCELLED;	/* Transform the endpoints */	ED_armature_sync_selection(arm->edbo);	WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);	return OPERATOR_FINISHED;}

/* Make copies of selected point segments in a selected stroke */static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes){	bGPDspoint *pt;	int i;		int start_idx = -1;			/* Step through the original stroke's points:	 * - We accumulate selected points (from start_idx to current index)	 *   and then convert that to a new stroke	 */	for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {		/* searching for start, are waiting for end? */		if (start_idx == -1) {			/* is this the first selected point for a new island? */			if (pt->flag & GP_SPOINT_SELECT) {				start_idx = i;			}		}		else {			size_t len = 0;						/* is this the end of current island yet?			 * 1) Point i-1 was the last one that was selected			 * 2) Point i is the last in the array			 */			if ((pt->flag & GP_SPOINT_SELECT) == 0) {				len = i - start_idx;			}			else if (i == gps->totpoints - 1) {				len = i - start_idx + 1;			}			//printf("copying from %d to %d = %d/n", start_idx, i, len);					/* make copies of the relevant data */			if (len) {				bGPDstroke *gpsd;								/* make a stupid copy first of the entire stroke (to get the flags too) */				gpsd = MEM_dupallocN(gps);								/* initialize triangle memory - will be calculated on next redraw */				gpsd->triangles = NULL;				gpsd->flag |= GP_STROKE_RECALC_CACHES;				gpsd->tot_triangles = 0;								/* now, make a new points array, and copy of the relevant parts */				gpsd->points = MEM_callocN(sizeof(bGPDspoint) * len, "gps stroke points copy");				memcpy(gpsd->points, gps->points + start_idx, sizeof(bGPDspoint) * len);				gpsd->totpoints = len;								/* add to temp buffer */				gpsd->next = gpsd->prev = NULL;				BLI_addtail(new_strokes, gpsd);								/* cleanup + reset for next */				start_idx = -1;			}		}	}}

static void time_draw_cache(SpaceTime *stime, Object *ob, Scene *scene){	PTCacheID *pid;	ListBase pidlist;	SpaceTimeCache *stc = stime->caches.first;	const float cache_draw_height = (4.0f * UI_DPI_FAC * U.pixelsize);	float yoffs = 0.f;		if (!(stime->cache_display & TIME_CACHE_DISPLAY) || (!ob))		return;	BKE_ptcache_ids_from_object(&pidlist, ob, scene, 0);	/* iterate over pointcaches on the active object, 	 * add spacetimecache and vertex array for each */	for (pid = pidlist.first; pid; pid = pid->next) {		float col[4], *fp;		int i, sta = pid->cache->startframe, end = pid->cache->endframe;		int len = (end - sta + 1) * 4;		switch (pid->type) {			case PTCACHE_TYPE_SOFTBODY:				if (!(stime->cache_display & TIME_CACHE_SOFTBODY)) continue;				break;			case PTCACHE_TYPE_PARTICLES:				if (!(stime->cache_display & TIME_CACHE_PARTICLES)) continue;				break;			case PTCACHE_TYPE_CLOTH:				if (!(stime->cache_display & TIME_CACHE_CLOTH)) continue;				break;			case PTCACHE_TYPE_SMOKE_DOMAIN:			case PTCACHE_TYPE_SMOKE_HIGHRES:				if (!(stime->cache_display & TIME_CACHE_SMOKE)) continue;				break;			case PTCACHE_TYPE_DYNAMICPAINT:				if (!(stime->cache_display & TIME_CACHE_DYNAMICPAINT)) continue;				break;			case PTCACHE_TYPE_RIGIDBODY:				if (!(stime->cache_display & TIME_CACHE_RIGIDBODY)) continue;				break;		}		if (pid->cache->cached_frames == NULL)			continue;		/* make sure we have stc with correct array length */		if (stc == NULL || MEM_allocN_len(stc->array) != len * 2 * sizeof(float)) {			if (stc) {				MEM_freeN(stc->array);			}			else {				stc = MEM_callocN(sizeof(SpaceTimeCache), "spacetimecache");				BLI_addtail(&stime->caches, stc);			}			stc->array = MEM_callocN(len * 2 * sizeof(float), "SpaceTimeCache array");		}		/* fill the vertex array with a quad for each cached frame */		for (i = sta, fp = stc->array; i <= end; i++) {			if (pid->cache->cached_frames[i - sta]) {				fp[0] = (float)i - 0.5f;				fp[1] = 0.0;				fp += 2;								fp[0] = (float)i - 0.5f;				fp[1] = 1.0;				fp += 2;								fp[0] = (float)i + 0.5f;				fp[1] = 1.0;				fp += 2;								fp[0] = (float)i + 0.5f;				fp[1] = 0.0;				fp += 2;			}		}				glPushMatrix();		glTranslatef(0.0, (float)V2D_SCROLL_HEIGHT + yoffs, 0.0);		glScalef(1.0, cache_draw_height, 0.0);				switch (pid->type) {			case PTCACHE_TYPE_SOFTBODY:				col[0] = 1.0;   col[1] = 0.4;   col[2] = 0.02;				col[3] = 0.1;				break;			case PTCACHE_TYPE_PARTICLES:				col[0] = 1.0;   col[1] = 0.1;   col[2] = 0.02;				col[3] = 0.1;				break;			case PTCACHE_TYPE_CLOTH:				col[0] = 0.1;   col[1] = 0.1;   col[2] = 0.75;				col[3] = 0.1;				break;			case PTCACHE_TYPE_SMOKE_DOMAIN:			case PTCACHE_TYPE_SMOKE_HIGHRES:				col[0] = 0.2;   col[1] = 0.2;   col[2] = 0.2;				col[3] = 0.1;//.........这里部分代码省略.........

/* Selects all visible keyframes in the same frames as the specified elements */static void columnselect_action_keys(bAnimContext *ac, short mode){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		Scene *scene = ac->scene;	CfraElem *ce;	KeyframeEditFunc select_cb, ok_cb;	KeyframeEditData ked = {{NULL}};		/* initialize keyframe editing data */		/* build list of columns */	switch (mode) {		case ACTKEYS_COLUMNSEL_KEYS: /* list of selected keys */			if (ac->datatype == ANIMCONT_GPENCIL) {				filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE);				ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);								for (ale = anim_data.first; ale; ale = ale->next)					ED_gplayer_make_cfra_list(ale->data, &ked.list, 1);			}			else {				filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY*/);				ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);								for (ale = anim_data.first; ale; ale = ale->next)					ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_to_cfraelem, NULL);			}			ANIM_animdata_freelist(&anim_data);			break;					case ACTKEYS_COLUMNSEL_CFRA: /* current frame */			/* make a single CfraElem for storing this */			ce = MEM_callocN(sizeof(CfraElem), "cfraElem");			BLI_addtail(&ked.list, ce);						ce->cfra = (float)CFRA;			break;					case ACTKEYS_COLUMNSEL_MARKERS_COLUMN: /* list of selected markers */			ED_markers_make_cfra_list(ac->markers, &ked.list, SELECT);			break;					default: /* invalid option */			return;	}		/* set up BezTriple edit callbacks */	select_cb = ANIM_editkeyframes_select(SELECT_ADD);	ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAME);		/* loop through all of the keys and select additional keyframes	 * based on the keys found to be selected above	 */	if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK))		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE);	else		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY*/);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(ac, ale);				/* loop over cfraelems (stored in the KeyframeEditData->list)		 *	- we need to do this here, as we can apply fewer NLA-mapping conversions		 */		for (ce = ked.list.first; ce; ce = ce->next) {			/* set frame for validation callback to refer to */			if (adt)				ked.f1 = BKE_nla_tweakedit_remap(adt, ce->cfra, NLATIME_CONVERT_UNMAP);			else				ked.f1 = ce->cfra;						/* select elements with frame number matching cfraelem */			if (ale->type == ANIMTYPE_GPLAYER)				ED_gpencil_select_frame(ale->data, ce->cfra, SELECT_ADD);			else if (ale->type == ANIMTYPE_MASKLAYER)				ED_mask_select_frame(ale->data, ce->cfra, SELECT_ADD);			else				ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);		}	}		/* free elements */	BLI_freelistN(&ked.list);	ANIM_animdata_freelist(&anim_data);}

//.........这里部分代码省略.........		/* filter data */	filter= (ACTFILTER_VISIBLE | ACTFILTER_SEL | ACTFILTER_FOREDIT);	actdata_filter(&act_data, filter, data, datatype);		/* from selected channels */	for (ale= act_data.first; ale; ale= ale->next) {		bGPDlayer *gpld= (bGPDlayer *)ale->data;		bGPDlayer *gpls= NULL;		bGPDframe *gpfs, *gpf;				/* find suitable layer from buffer to use to paste from */		for (gpls= gpcopybuf.first; gpls; gpls= gpls->next) {			/* check if layer name matches */			if ((no_name) || (strcmp(gpls->info, gpld->info)==0))				break;		}				/* this situation might occur! */		if (gpls == NULL)			continue;				/* add frames from buffer */		for (gpfs= gpls->frames.first; gpfs; gpfs= gpfs->next) {			/* temporarily apply offset to buffer-frame while copying */			gpfs->framenum += offset;						/* get frame to copy data into (if no frame returned, then just ignore) */			gpf= gpencil_layer_getframe(gpld, gpfs->framenum, 1);			if (gpf) {				bGPDstroke *gps, *gpsn;				ScrArea *sa;								/* get area that gp-data comes from */				//sa= gpencil_data_findowner((bGPdata *)ale->owner);					sa = NULL;								/* this should be the right frame... as it may be a pre-existing frame, 				 * must make sure that only compatible stroke types get copied over 				 *	- we cannot just add a duplicate frame, as that would cause errors				 *	- need to check for compatible types to minimise memory usage (copying 'junk' over)				 */				for (gps= gpfs->strokes.first; gps; gps= gps->next) {					short stroke_ok;										/* if there's an area, check that it supports this type of stroke */					if (sa) {						stroke_ok= 0;												/* check if spacetype supports this type of stroke						 *	- NOTE: must sync this with gp_paint_initstroke() in gpencil.c						 */						switch (sa->spacetype) {							case SPACE_VIEW3D: /* 3D-View: either screen-aligned or 3d-space */								if ((gps->flag == 0) || (gps->flag & GP_STROKE_3DSPACE))									stroke_ok= 1;								break;															case SPACE_NODE: /* Nodes Editor: either screen-aligned or view-aligned */							case SPACE_IMAGE: /* Image Editor: either screen-aligned or view/image-aligned */								if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DSPACE))									stroke_ok= 1;								break;															case SPACE_SEQ: /* Sequence Editor: either screen-aligned or view-aligned */								if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DIMAGE))									stroke_ok= 1;								break;						}					}					else						stroke_ok= 1;										/* if stroke is ok, we make a copy of this stroke and add to frame */					if (stroke_ok) {						/* make a copy of stroke, then of its points array */						gpsn= MEM_dupallocN(gps);						gpsn->points= MEM_dupallocN(gps->points);												/* append stroke to frame */						BLI_addtail(&gpf->strokes, gpsn);					}				}								/* if no strokes (i.e. new frame) added, free gpf */				if (gpf->strokes.first == NULL)					gpencil_layer_delframe(gpld, gpf);			}						/* unapply offset from buffer-frame */			gpfs->framenum -= offset;		}	}		/* free temp memory */	BLI_freelistN(&act_data);		/* undo and redraw stuff */	BIF_undo_push("Paste Grease Pencil Frames");}

static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf){	Object *obedit = CTX_data_edit_object(C);	ListBase *editnurb;	Nurb *nu;	bool newob = false;	bool enter_editmode;	unsigned int layer;	float dia;	float loc[3], rot[3];	float mat[4][4];	WM_operator_view3d_unit_defaults(C, op);	if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &layer, NULL))		return OPERATOR_CANCELLED;	if (!isSurf) { /* adding curve */		if (obedit == NULL || obedit->type != OB_CURVE) {			Curve *cu;			obedit = ED_object_add_type(C, OB_CURVE, loc, rot, true, layer);			newob = true;			cu = (Curve *)obedit->data;			cu->flag |= CU_DEFORM_FILL;			if (type & CU_PRIM_PATH)				cu->flag |= CU_PATH | CU_3D;		}		else {			DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);		}	}	else { /* adding surface */		if (obedit == NULL || obedit->type != OB_SURF) {			obedit = ED_object_add_type(C, OB_SURF, loc, rot, true, layer);			newob = true;		}		else {			DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);		}	}	/* rename here, the undo stack checks name for valid undo pushes */	if (newob) {		if (obedit->type == OB_CURVE) {			rename_id((ID *)obedit, get_curve_defname(type));			rename_id((ID *)obedit->data, get_curve_defname(type));		}		else {			rename_id((ID *)obedit, get_surf_defname(type));			rename_id((ID *)obedit->data, get_surf_defname(type));		}	}	/* ED_object_add_type doesnt do an undo, is needed for redo operator on primitive */	if (newob && enter_editmode)		ED_undo_push(C, "Enter Editmode");	ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);	dia = RNA_float_get(op->ptr, "radius");	mul_mat3_m4_fl(mat, dia);	nu = add_nurbs_primitive(C, obedit, mat, type, newob);	editnurb = object_editcurve_get(obedit);	BLI_addtail(editnurb, nu);	/* userdef */	if (newob && !enter_editmode) {		ED_object_editmode_exit(C, EM_FREEDATA);	}	WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);	return OPERATOR_FINISHED;}

//.........这里部分代码省略.........				nu->orderu = 4;				nu->orderv = 4;				nu->flag = CU_SMOOTH;				nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * (4 * 4), "addNurbprim6");				nu->flagu = 0;				nu->flagv = 0;				bp = nu->bp;				for (a = 0; a < 4; a++) {					for (b = 0; b < 4; b++) {						bp->f1 = SELECT;						fac = (float)a - 1.5f;						bp->vec[0] += fac * grid;						fac = (float)b - 1.5f;						bp->vec[1] += fac * grid;						if ((a == 1 || a == 2) && (b == 1 || b == 2)) {							bp->vec[2] += grid;						}						mul_m4_v3(mat, bp->vec);						bp->vec[3] = 1.0;						bp++;					}				}				BKE_nurb_knot_calc_u(nu);				BKE_nurb_knot_calc_v(nu);			}			break;		case CU_PRIM_TUBE: /* Cylinder */			if (cutype == CU_NURBS) {				nu = add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0); /* circle */				nu->resolu = cu->resolu;				nu->flag = CU_SMOOTH;				BLI_addtail(editnurb, nu); /* temporal for extrude and translate */				vec[0] = vec[1] = 0.0;				vec[2] = -grid;				mul_mat3_m4_v3(mat, vec);				ed_editnurb_translate_flag(editnurb, SELECT, vec);				ed_editnurb_extrude_flag(cu->editnurb, SELECT);				mul_v3_fl(vec, -2.0f);				ed_editnurb_translate_flag(editnurb, SELECT, vec);				BLI_remlink(editnurb, nu);				a = nu->pntsu * nu->pntsv;				bp = nu->bp;				while (a-- > 0) {					bp->f1 |= SELECT;					bp++;				}			}			break;		case CU_PRIM_SPHERE: /* sphere */			if (cutype == CU_NURBS) {				float tmp_cent[3] = {0.f, 0.f, 0.f};				float tmp_vec[3] = {0.f, 0.f, 1.f};				nu->pntsu = 5;				nu->pntsv = 1;				nu->orderu = 3;				nu->resolu = cu->resolu;				nu->resolv = cu->resolv;				nu->flag = CU_SMOOTH;				nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * 5, "addNurbprim6");

/* This function adds data to the keyframes copy/paste buffer, freeing existing data first */short copy_animedit_keys(bAnimContext *ac, ListBase *anim_data){		bAnimListElem *ale;	Scene *scene = ac->scene;		/* clear buffer first */	free_anim_copybuf();		/* assume that each of these is an F-Curve */	for (ale = anim_data->first; ale; ale = ale->next) {		FCurve *fcu = (FCurve *)ale->key_data;		tAnimCopybufItem *aci;		BezTriple *bezt, *nbezt, *newbuf;		int i;				/* firstly, check if F-Curve has any selected keyframes		 *	- skip if no selected keyframes found (so no need to create unnecessary copy-buffer data)		 *	- this check should also eliminate any problems associated with using sample-data		 */		if (ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, ANIM_editkeyframes_ok(BEZT_OK_SELECTED), NULL) == 0)			continue;				/* init copybuf item info */		aci = MEM_callocN(sizeof(tAnimCopybufItem), "AnimCopybufItem");		aci->id = ale->id;		aci->id_type = GS(ale->id->name);		aci->grp = fcu->grp;		aci->rna_path = MEM_dupallocN(fcu->rna_path);		aci->array_index = fcu->array_index;		BLI_addtail(&animcopybuf, aci);				/* add selected keyframes to buffer */		/* TODO: currently, we resize array every time we add a new vert -		 * this works ok as long as it is assumed only a few keys are copied */		for (i = 0, bezt = fcu->bezt; i < fcu->totvert; i++, bezt++) {			if (BEZSELECTED(bezt)) {				/* add to buffer */				newbuf = MEM_callocN(sizeof(BezTriple) * (aci->totvert + 1), "copybuf beztriple");								/* assume that since we are just re-sizing the array, just copy all existing data across */				if (aci->bezt)					memcpy(newbuf, aci->bezt, sizeof(BezTriple) * (aci->totvert));								/* copy current beztriple across too */				nbezt = &newbuf[aci->totvert];				*nbezt = *bezt;								/* ensure copy buffer is selected so pasted keys are selected */				BEZ_SEL(nbezt);								/* free old array and set the new */				if (aci->bezt) MEM_freeN(aci->bezt);				aci->bezt = newbuf;				aci->totvert++;								/* check if this is the earliest frame encountered so far */				if (bezt->vec[1][0] < animcopy_firstframe)					animcopy_firstframe = bezt->vec[1][0];				if (bezt->vec[1][0] > animcopy_lastframe)					animcopy_lastframe = bezt->vec[1][0];			}		}			}		/* check if anything ended up in the buffer */	if (ELEM(NULL, animcopybuf.first, animcopybuf.last))		return -1;	/* in case 'relative' paste method is used */	animcopy_cfra = CFRA;	/* everything went fine */	return 0;}

/* Get (or add relevant data to be able to do so) F-Curve from the driver stack,  * for the given Animation Data block. This assumes that all the destinations are valid. *	 *	- add:	0 - don't add anything if not found,  *			1 - add new Driver FCurve (with keyframes for visual tweaking), *			2 - add new Driver FCurve (with generator, for script backwards compatibility) *			-1 - add new Driver FCurve without driver stuff (for pasting) */FCurve *verify_driver_fcurve(ID *id, const char rna_path[], const int array_index, short add){	AnimData *adt;	FCurve *fcu;		/* sanity checks */	if (ELEM(NULL, id, rna_path))		return NULL;		/* init animdata if none available yet */	adt = BKE_animdata_from_id(id);	if ((adt == NULL) && (add))		adt = BKE_id_add_animdata(id);	if (adt == NULL) {		/* if still none (as not allowed to add, or ID doesn't have animdata for some reason) */		return NULL;	}			/* try to find f-curve matching for this setting 	 *	- add if not found and allowed to add one	 *		TODO: add auto-grouping support? how this works will need to be resolved	 */	fcu = list_find_fcurve(&adt->drivers, rna_path, array_index);		if ((fcu == NULL) && (add)) {		/* use default settings to make a F-Curve */		fcu = MEM_callocN(sizeof(FCurve), "FCurve");				fcu->flag = (FCURVE_VISIBLE | FCURVE_SELECTED);				/* store path - make copy, and store that */		fcu->rna_path = BLI_strdupn(rna_path, strlen(rna_path));		fcu->array_index = array_index;				/* if add is negative, don't init this data yet, since it will be filled in by the pasted driver */		if (add > 0) {			BezTriple *bezt;			size_t i;						/* add some new driver data */			fcu->driver = MEM_callocN(sizeof(ChannelDriver), "ChannelDriver");			fcu->driver->flag |= DRIVER_FLAG_SHOWDEBUG;						/* F-Modifier or Keyframes? */			// FIXME: replace these magic numbers with defines			if (add == 2) {				/* Python API Backwards compatibility hack:				 * Create FModifier so that old scripts won't break				 * for now before 2.7 series -- (September 4, 2013)				 */				add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_GENERATOR);			}			else {				/* add 2 keyframes so that user has something to work with 				 * - These are configured to 0,0 and 1,1 to give a 1-1 mapping				 *   which can be easily tweaked from there.				 */				insert_vert_fcurve(fcu, 0.0f, 0.0f, INSERTKEY_FAST);				insert_vert_fcurve(fcu, 1.0f, 1.0f, INSERTKEY_FAST);								/* configure this curve to extrapolate */				for (i = 0, bezt = fcu->bezt;  (i < fcu->totvert) && bezt;  i++, bezt++) {					bezt->h1 = bezt->h2 = HD_VECT;				}								fcu->extend = FCURVE_EXTRAPOLATE_LINEAR;				calchandles_fcurve(fcu);			}		}				/* just add F-Curve to end of driver list */		BLI_addtail(&adt->drivers, fcu);	}		/* return the F-Curve */	return fcu;}

static void screen_opengl_views_setup(OGLRender *oglrender){	RenderResult *rr;	RenderView *rv;	SceneRenderView *srv;	bool is_multiview;	View3D *v3d = oglrender->v3d;	RenderData *rd = &oglrender->scene->r;	rr = RE_AcquireResultWrite(oglrender->re);	is_multiview = screen_opengl_is_multiview(oglrender);	if (!is_multiview) {		/* we only have one view when multiview is off */		rv = rr->views.first;		if (rv == NULL) {			rv = MEM_callocN(sizeof(RenderView), "new opengl render view");			BLI_addtail(&rr->views, rv);		}		while (rv->next) {			RenderView *rv_del = rv->next;			BLI_remlink(&rr->views, rv_del);			if (rv_del->rectf)				MEM_freeN(rv_del->rectf);			if (rv_del->rectz)				MEM_freeN(rv_del->rectz);			MEM_freeN(rv_del);		}	}	else {		if (!oglrender->is_sequencer)			RE_SetOverrideCamera(oglrender->re, V3D_CAMERA_SCENE(oglrender->scene, v3d));		/* remove all the views that are not needed */		rv = rr->views.last;		while (rv) {			srv = BLI_findstring(&rd->views, rv->name, offsetof(SceneRenderView, name));			if (BKE_scene_multiview_is_render_view_active(rd, srv)) {				if (rv->rectf == NULL)					rv->rectf = MEM_callocN(sizeof(float) * 4 * oglrender->sizex * oglrender->sizey, "screen_opengl_render_init rect");				rv = rv->prev;			}			else {				RenderView *rv_del = rv;				rv  = rv_del->prev;				BLI_remlink(&rr->views, rv_del);				if (rv_del->rectf)					MEM_freeN(rv_del->rectf);				if (rv_del->rectz)					MEM_freeN(rv_del->rectz);				MEM_freeN(rv_del);			}		}		/* create all the views that are needed */		for (srv = rd->views.first; srv; srv = srv->next) {			if (BKE_scene_multiview_is_render_view_active(rd, srv) == false)				continue;			rv = BLI_findstring(&rr->views, srv->name, offsetof(SceneRenderView, name));			if (rv == NULL) {				rv = MEM_callocN(sizeof(RenderView), "new opengl render view");				BLI_strncpy(rv->name, srv->name, sizeof(rv->name));				BLI_addtail(&rr->views, rv);			}		}	}	for (rv = rr->views.first; rv; rv = rv->next) {		if (rv->rectf == NULL) {			rv->rectf = MEM_callocN(sizeof(float) * 4 * oglrender->sizex * oglrender->sizey, "screen_opengl_render_init rect");		}	}	BLI_lock_thread(LOCK_DRAW_IMAGE);	if (is_multiview && BKE_scene_multiview_is_stereo3d(rd)) {		oglrender->ima->flag |= IMA_IS_STEREO;	}	else {		oglrender->ima->flag &= ~IMA_IS_STEREO;		oglrender->iuser.flag &= ~IMA_SHOW_STEREO;	}	BLI_unlock_thread(LOCK_DRAW_IMAGE);	RE_ReleaseResult(oglrender->re);}

/* reading without uifont will create one */void uiStyleInit(void){	uiFont *font;	uiStyle *style = U.uistyles.first;	int monofont_size = datatoc_bmonofont_ttf_size;	unsigned char *monofont_ttf = (unsigned char *)datatoc_bmonofont_ttf;	/* recover from uninitialized dpi */	if (U.dpi == 0)		U.dpi = 72;	CLAMP(U.dpi, 48, 144);	for (font = U.uifonts.first; font; font = font->next) {		BLF_unload_id(font->blf_id);	}	if (blf_mono_font != -1) {		BLF_unload_id(blf_mono_font);		blf_mono_font = -1;	}	if (blf_mono_font_render != -1) {		BLF_unload_id(blf_mono_font_render);		blf_mono_font_render = -1;	}	font = U.uifonts.first;	/* default builtin */	if (font == NULL) {		font = MEM_callocN(sizeof(uiFont), "ui font");		BLI_addtail(&U.uifonts, font);	}	if (U.font_path_ui[0]) {		BLI_strncpy(font->filename, U.font_path_ui, sizeof(font->filename));		font->uifont_id = UIFONT_CUSTOM1;	}	else {		BLI_strncpy(font->filename, "default", sizeof(font->filename));		font->uifont_id = UIFONT_DEFAULT;	}	for (font = U.uifonts.first; font; font = font->next) {		if (font->uifont_id == UIFONT_DEFAULT) {#ifdef WITH_INTERNATIONAL			int font_size = datatoc_bfont_ttf_size;			unsigned char *font_ttf = (unsigned char *)datatoc_bfont_ttf;			static int last_font_size = 0;			/* use unicode font for translation */			if (U.transopts & USER_DOTRANSLATE) {				font_ttf = BLF_get_unifont(&font_size);				if (!font_ttf) {					/* fall back if not found */					font_size = datatoc_bfont_ttf_size;					font_ttf = (unsigned char *)datatoc_bfont_ttf;				}			}			/* relload only if needed */			if (last_font_size != font_size) {				BLF_unload("default");				last_font_size = font_size;			}			font->blf_id = BLF_load_mem("default", font_ttf, font_size);#else			font->blf_id = BLF_load_mem("default", (unsigned char *)datatoc_bfont_ttf, datatoc_bfont_ttf_size);#endif		}		else {			font->blf_id = BLF_load(font->filename);			if (font->blf_id == -1) {				font->blf_id = BLF_load_mem("default", (unsigned char *)datatoc_bfont_ttf, datatoc_bfont_ttf_size);			}		}		BLF_default_set(font->blf_id);		if (font->blf_id == -1) {			if (G.debug & G_DEBUG)				printf("%s: error, no fonts available/n", __func__);		}		else {			/* ? just for speed to initialize?			 * Yes, this build the glyph cache and create			 * the texture.			 */			BLF_size(font->blf_id, 11 * U.pixelsize, U.dpi);			BLF_size(font->blf_id, 12 * U.pixelsize, U.dpi);			BLF_size(font->blf_id, 14 * U.pixelsize, U.dpi);		}	}	if (style == NULL) {		ui_style_new(&U.uistyles, "Default Style", UIFONT_DEFAULT);//.........这里部分代码省略.........

static int gp_duplicate_exec(bContext *C, wmOperator *op){	bGPdata *gpd = ED_gpencil_data_get_active(C);		if (gpd == NULL) {		BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data");		return OPERATOR_CANCELLED;	}		/* for each visible (and editable) layer's selected strokes,	 * copy the strokes into a temporary buffer, then append	 * once all done	 */	CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers)	{		ListBase new_strokes = {NULL, NULL};		bGPDframe *gpf = gpl->actframe;		bGPDstroke *gps;				if (gpf == NULL)			continue;				/* make copies of selected strokes, and deselect these once we're done */		for (gps = gpf->strokes.first; gps; gps = gps->next) {			/* skip strokes that are invalid for current view */			if (ED_gpencil_stroke_can_use(C, gps) == false)				continue;						if (gps->flag & GP_STROKE_SELECT) {				if (gps->totpoints == 1) {					/* Special Case: If there's just a single point in this stroke... */					bGPDstroke *gpsd;										/* make direct copies of the stroke and its points */					gpsd = MEM_dupallocN(gps);					gpsd->points = MEM_dupallocN(gps->points);										/* triangle information - will be calculated on next redraw */					gpsd->flag |= GP_STROKE_RECALC_CACHES;					gpsd->triangles = NULL;										/* add to temp buffer */					gpsd->next = gpsd->prev = NULL;					BLI_addtail(&new_strokes, gpsd);				}				else {					/* delegate to a helper, as there's too much to fit in here (for copying subsets)... */					gp_duplicate_points(gps, &new_strokes);				}								/* deselect original stroke, or else the originals get moved too				 * (when using the copy + move macro)				 */				gps->flag &= ~GP_STROKE_SELECT;			}		}				/* add all new strokes in temp buffer to the frame (preventing double-copies) */		BLI_movelisttolist(&gpf->strokes, &new_strokes);		BLI_assert(new_strokes.first == NULL);	}

/* name can be a dynamic string */void BKE_undo_write(bContext *C, const char *name){	int nr /*, success */ /* UNUSED */;	UndoElem *uel;	if ((U.uiflag & USER_GLOBALUNDO) == 0) {		return;	}	if (U.undosteps == 0) {		return;	}	/* remove all undos after (also when curundo == NULL) */	while (undobase.last != curundo) {		uel = undobase.last;		BLI_remlink(&undobase, uel);		BLO_memfile_free(&uel->memfile);		MEM_freeN(uel);	}	/* make new */	curundo = uel = MEM_callocN(sizeof(UndoElem), "undo file");	BLI_strncpy(uel->name, name, sizeof(uel->name));	BLI_addtail(&undobase, uel);	/* and limit amount to the maximum */	nr = 0;	uel = undobase.last;	while (uel) {		nr++;		if (nr == U.undosteps) break;		uel = uel->prev;	}	if (uel) {		while (undobase.first != uel) {			UndoElem *first = undobase.first;			BLI_remlink(&undobase, first);			/* the merge is because of compression */			BLO_memfile_merge(&first->memfile, &first->next->memfile);			MEM_freeN(first);		}	}	/* disk save version */	if (UNDO_DISK) {		static int counter = 0;		char filename[FILE_MAX];		char numstr[32];		int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on undo */		/* Calculate current filename. */		counter++;		counter = counter % U.undosteps;		BLI_snprintf(numstr, sizeof(numstr), "%d.blend", counter);		BLI_make_file_string("/", filename, BKE_tempdir_session(), numstr);		/* success = */ /* UNUSED */ BLO_write_file(CTX_data_main(C), filename, fileflags, NULL, NULL);		BLI_strncpy(curundo->filename, filename, sizeof(curundo->filename));	}	else {		MemFile *prevfile = NULL;		if (curundo->prev) prevfile = &(curundo->prev->memfile);		/* success = */ /* UNUSED */ BLO_write_file_mem(CTX_data_main(C), prevfile, &curundo->memfile, G.fileflags);		curundo->undo_size = curundo->memfile.size;	}	if (U.undomemory != 0) {		size_t maxmem, totmem;		/* limit to maximum memory (afterwards, we can't know in advance) */		totmem = 0;		maxmem = ((size_t)U.undomemory) * 1024 * 1024;		/* keep at least two (original + other) */		uel = undobase.last;		while (uel && uel->prev) {			totmem += uel->undo_size;			if (totmem > maxmem) break;			uel = uel->prev;		}		if (uel) {			if (uel->prev && uel->prev->prev)				uel = uel->prev;			while (undobase.first != uel) {				UndoElem *first = undobase.first;				BLI_remlink(&undobase, first);				/* the merge is because of compression */				BLO_memfile_merge(&first->memfile, &first->next->memfile);				MEM_freeN(first);			}		}	}//.........这里部分代码省略.........

/* * - loop over selected shapekeys. * - find firstsel/lastsel pairs. * - move these into a temp list. * - re-key all the original shapes. * - copy unselected values back from the original. * - free the original. */static int mask_shape_key_rekey_exec(bContext *C, wmOperator *op){	Scene *scene = CTX_data_scene(C);	const int frame = CFRA;	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	bool changed = false;	const bool do_feather  = RNA_boolean_get(op->ptr, "feather");	const bool do_location = RNA_boolean_get(op->ptr, "location");	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		/* we need at least one point selected here to bother re-interpolating */		if (!ED_mask_layer_select_check(masklay)) {			continue;		}		if (masklay->splines_shapes.first) {			MaskLayerShape *masklay_shape, *masklay_shape_next;			MaskLayerShape *masklay_shape_lastsel = NULL;			for (masklay_shape = masklay->splines_shapes.first;			     masklay_shape;			     masklay_shape = masklay_shape_next)			{				MaskLayerShape *masklay_shape_a = NULL;				MaskLayerShape *masklay_shape_b = NULL;				masklay_shape_next = masklay_shape->next;				/* find contiguous selections */				if (masklay_shape->flag & MASK_SHAPE_SELECT) {					if (masklay_shape_lastsel == NULL) {						masklay_shape_lastsel = masklay_shape;					}					if ((masklay_shape->next == NULL) ||					    (((MaskLayerShape *)masklay_shape->next)->flag & MASK_SHAPE_SELECT) == 0)					{						masklay_shape_a = masklay_shape_lastsel;						masklay_shape_b = masklay_shape;						masklay_shape_lastsel = NULL;						/* this will be freed below, step over selection */						masklay_shape_next = masklay_shape->next;					}				}				/* we have a from<>to? - re-interpolate! */				if (masklay_shape_a && masklay_shape_b) {					ListBase shapes_tmp = {NULL, NULL};					MaskLayerShape *masklay_shape_tmp;					MaskLayerShape *masklay_shape_tmp_next;					MaskLayerShape *masklay_shape_tmp_last = masklay_shape_b->next;					MaskLayerShape *masklay_shape_tmp_rekey;					/* move keys */					for (masklay_shape_tmp = masklay_shape_a;					     masklay_shape_tmp && (masklay_shape_tmp != masklay_shape_tmp_last);					     masklay_shape_tmp = masklay_shape_tmp_next)					{						masklay_shape_tmp_next = masklay_shape_tmp->next;						BLI_remlink(&masklay->splines_shapes, masklay_shape_tmp);						BLI_addtail(&shapes_tmp, masklay_shape_tmp);					}					/* re-key, note: cant modify the keys here since it messes uop */					for (masklay_shape_tmp = shapes_tmp.first;					     masklay_shape_tmp;					     masklay_shape_tmp = masklay_shape_tmp->next)					{						BKE_mask_layer_evaluate(masklay, masklay_shape_tmp->frame, true);						masklay_shape_tmp_rekey = BKE_mask_layer_shape_verify_frame(masklay, masklay_shape_tmp->frame);						BKE_mask_layer_shape_from_mask(masklay, masklay_shape_tmp_rekey);						masklay_shape_tmp_rekey->flag = masklay_shape_tmp->flag & MASK_SHAPE_SELECT;					}					/* restore unselected points and free copies */					for (masklay_shape_tmp = shapes_tmp.first;					     masklay_shape_tmp;					     masklay_shape_tmp = masklay_shape_tmp_next)					{						/* restore */						int i_abs = 0;						int i;						MaskSpline *spline;						MaskLayerShapeElem *shape_ele_src;						MaskLayerShapeElem *shape_ele_dst;//.........这里部分代码省略.........

static int armature_subdivide_exec(bContext *C, wmOperator *op){	Object *obedit = CTX_data_edit_object(C);	bArmature *arm = obedit->data;	EditBone *newbone, *tbone;	int cuts, i;		/* there may not be a number_cuts property defined (for 'simple' subdivide) */	cuts = RNA_int_get(op->ptr, "number_cuts");		/* loop over all editable bones */	// XXX the old code did this in reverse order though!	CTX_DATA_BEGIN(C, EditBone *, ebone, selected_editable_bones)	{		for (i = cuts + 1; i > 1; i--) {			/* compute cut ratio first */			float cutratio = 1.0f / (float)i;			float cutratioI = 1.0f - cutratio;						float val1[3];			float val2[3];			float val3[3];						newbone = MEM_mallocN(sizeof(EditBone), "ebone subdiv");			*newbone = *ebone;			BLI_addtail(arm->edbo, newbone);						/* calculate location of newbone->head */			copy_v3_v3(val1, ebone->head);			copy_v3_v3(val2, ebone->tail);			copy_v3_v3(val3, newbone->head);						val3[0] = val1[0] * cutratio + val2[0] * cutratioI;			val3[1] = val1[1] * cutratio + val2[1] * cutratioI;			val3[2] = val1[2] * cutratio + val2[2] * cutratioI;						copy_v3_v3(newbone->head, val3);			copy_v3_v3(newbone->tail, ebone->tail);			copy_v3_v3(ebone->tail, newbone->head);						newbone->rad_head = ((ebone->rad_head * cutratio) + (ebone->rad_tail * cutratioI));			ebone->rad_tail = newbone->rad_head;						newbone->flag |= BONE_CONNECTED;			newbone->prop = NULL;			unique_editbone_name(arm->edbo, newbone->name, NULL);						/* correct parent bones */			for (tbone = arm->edbo->first; tbone; tbone = tbone->next) {				if (tbone->parent == ebone)					tbone->parent = newbone;			}			newbone->parent = ebone;		}	}	CTX_DATA_END;		/* note, notifier might evolve */	WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);		return OPERATOR_FINISHED;}

/* * This thread is used to load video frame asynchronously. * It provides a frame caching service.  * The main thread is responsible for positioning the frame pointer in the * file correctly before calling startCache() which starts this thread. * The cache is organized in two layers: 1) a cache of 20-30 undecoded packets to keep * memory and CPU low 2) a cache of 5 decoded frames.  * If the main thread does not find the frame in the cache (because the video has restarted * or because the GE is lagging), it stops the cache with StopCache() (this is a synchronous * function: it sends a signal to stop the cache thread and wait for confirmation), then * change the position in the stream and restarts the cache thread. */void *VideoFFmpeg::cacheThread(void *data){	VideoFFmpeg* video = (VideoFFmpeg*)data;	// holds the frame that is being decoded	CacheFrame *currentFrame = NULL;	CachePacket *cachePacket;	bool endOfFile = false;	int frameFinished = 0;	double timeBase = av_q2d(video->m_formatCtx->streams[video->m_videoStream]->time_base);	int64_t startTs = video->m_formatCtx->streams[video->m_videoStream]->start_time;	if (startTs == AV_NOPTS_VALUE)		startTs = 0;	while (!video->m_stopThread)	{		// packet cache is used solely by this thread, no need to lock		// In case the stream/file contains other stream than the one we are looking for,		// allow a bit of cycling to get rid quickly of those frames		frameFinished = 0;		while (	   !endOfFile 				&& (cachePacket = (CachePacket *)video->m_packetCacheFree.first) != NULL 				&& frameFinished < 25)		{			// free packet => packet cache is not full yet, just read more			if (av_read_frame(video->m_formatCtx, &cachePacket->packet)>=0) 			{				if (cachePacket->packet.stream_index == video->m_videoStream)				{					// make sure fresh memory is allocated for the packet and move it to queue					av_dup_packet(&cachePacket->packet);					BLI_remlink(&video->m_packetCacheFree, cachePacket);					BLI_addtail(&video->m_packetCacheBase, cachePacket);					break;				} else {					// this is not a good packet for us, just leave it on free queue					// Note: here we could handle sound packet					av_free_packet(&cachePacket->packet);					frameFinished++;				}							} else {				if (video->m_isFile)					// this mark the end of the file					endOfFile = true;				// if we cannot read a packet, no need to continue				break;			}		}		// frame cache is also used by main thread, lock		if (currentFrame == NULL) 		{			// no current frame being decoded, take free one			pthread_mutex_lock(&video->m_cacheMutex);			if ((currentFrame = (CacheFrame *)video->m_frameCacheFree.first) != NULL)				BLI_remlink(&video->m_frameCacheFree, currentFrame);			pthread_mutex_unlock(&video->m_cacheMutex);		}		if (currentFrame != NULL)		{			// this frame is out of free and busy queue, we can manipulate it without locking			frameFinished = 0;			while (!frameFinished && (cachePacket = (CachePacket *)video->m_packetCacheBase.first) != NULL)			{				BLI_remlink(&video->m_packetCacheBase, cachePacket);				// use m_frame because when caching, it is not used in main thread				// we can't use currentFrame directly because we need to convert to RGB first				avcodec_decode_video2(video->m_codecCtx, 					video->m_frame, &frameFinished, 					&cachePacket->packet);				if (frameFinished) 				{					AVFrame * input = video->m_frame;					/* This means the data wasnt read properly, this check stops crashing */					if (   input->data[0]!=0 || input->data[1]!=0 						|| input->data[2]!=0 || input->data[3]!=0)					{						if (video->m_deinterlace) 						{							if (avpicture_deinterlace(								(AVPicture*) video->m_frameDeinterlaced,								(const AVPicture*) video->m_frame,								video->m_codecCtx->pix_fmt,								video->m_codecCtx->width,								video->m_codecCtx->height) >= 0)							{								input = video->m_frameDeinterlaced;//.........这里部分代码省略.........