Discussion :

[frezze]

Bonjour/Bonsoir,

j'ai utilisé FFmpeg pour faire une acquisition de flux via une caméra Ip ( Bosch autodome 4000). J'ai réussi à avoir un flux mais j'ai 2 problèmes, le problème qui me dérange le plus et le fait que mon stream "frezze" après 3 ou 4 secondes. j'ai testé le flux (l'URI) avec vlc je n'ai aucun problème. En réalité, je suis en train de faire des tests en c++ pour essayer de comprendre comment FFmpeg fonctionne, ensuite je dois faire un " wrapper " (emballage) pour l'utiliser en c#. je sais qu'il y a des Wrapper tous fait mais souvent ils sont mal faits où il se basse sure des anciennes de F. fmpeg.
le second problème est que les couleurs de l'image ne sont pas bonnes, par exemple il montre ma main en bleu. je pense que c'est dû au fait que je convertis mal mon image en bitmap, je la transforme en bitmap la frame que je reçois car pour la suite j'ai besoin d'une bitmap RGB ( AV_PIX_FMT_RGB24), de basse le frame a comme format AV_PIX_FMT_YUV420P

voici une image pour illustrer le problème

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
 
 
CMFCApplication1Dlg *pDlg = (CMFCApplication1Dlg *)carg;
	int64_t timeBase;
 
	char src_filename[180];
	int refcount = 0;
	int video_stream_idx = -1;
	int audio_stream_idx = -1;
	AVCodecContext *video_dec_ctx = NULL;
	AVStream *video_stream = NULL;
	AVFormatContext *fmt_ctx = NULL;
	int ret;
 
	strcpy_s(src_filename, 180, "rtsp://service:CyresCenco1*@172.26.48.202/rtsp_tunnel");
	//strcpy_s(src_filename, 180, "c:\\temp\\Test.avi");
 
	/* open input file, and allocate format context */
	//int ret = avformat_open_input(&fmt_ctx, "c:\\temp\\Test.avi", NULL, NULL);
	ret = avformat_open_input(&fmt_ctx, src_filename, NULL, NULL);
	if (ret < 0)
	{
		return -1;
	}
 
	ret = avformat_find_stream_info(fmt_ctx, NULL);
	if (ret < 0)
	{
		return -1;
	}
 
	int stream_index;
	AVStream *st;
	AVCodec *dec = NULL;
	AVDictionary *opts = NULL;
 
	ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
	if (ret < 0)
	{
		return -1;
	}
	else
	{
		stream_index = ret;
		st = fmt_ctx->streams[stream_index];
 
		/* find decoder for the stream */
		dec = avcodec_find_decoder(st->codecpar->codec_id);
		if (!dec)
		{
			return -1;
		}
 
		/* Allocate a codec context for the decoder */
		video_dec_ctx = avcodec_alloc_context3(dec);
		if (!video_dec_ctx)
		{
			return -1;
		}
 
		/* Copy codec parameters from input stream to output codec context */
		if ((ret = avcodec_parameters_to_context(video_dec_ctx, st->codecpar)) < 0)
		{
			fprintf(stderr, "Failed to copy %s codec parameters to decoder context\n",
				av_get_media_type_string(AVMEDIA_TYPE_VIDEO));
			return -1;
		}
 
		/* Init the decoders, with or without reference counting */
		av_dict_set(&opts, "refcounted_frames", refcount ? "1" : "0", 0);
		if ((ret = avcodec_open2(video_dec_ctx, dec, &opts)) < 0)
		{
			return -1;
		}
		video_stream_idx = stream_index;
	}
 
	video_stream = fmt_ctx->streams[video_stream_idx];
 
	/*FILE *video_dst_file = fopen("d:\\temp\\ocack.avi", "wb");
	if (!video_dst_file)
	{
		return -1;
	}*/
 
	/* allocate image where the decoded image will be put */
	int width_src, height_src;
	enum AVPixelFormat pix_fmt_src, pix_fmt_dst;
 
	uint8_t *video_tmp_data[4] = { NULL };
	int      video_tmp_linesize[4];
 
	uint8_t *video_dst_data[4] = { NULL };
	int      video_dst_linesize[4];
	width_src = video_dec_ctx->width;
	height_src = video_dec_ctx->height;
	pix_fmt_src = video_dec_ctx->pix_fmt;
	pix_fmt_dst = AV_PIX_FMT_RGB24;
 
	//AfxMessageBox(av_get_pix_fmt_name(pix_fmt_dst));
 
	ret = av_image_alloc(video_tmp_data, video_tmp_linesize,
		width_src, height_src, pix_fmt_src, 1); 
 
	ret = av_image_alloc(video_dst_data, video_dst_linesize,
		width_src, height_src, pix_fmt_dst /* pix_fmt_src */, 1);
	if (ret < 0)
	{
		return -1;
	}
	int video_dst_bufsize = ret;
 
	av_dump_format(fmt_ctx, 0, src_filename, 0);
 
	if (!video_stream)
	{
		return -1;
	}
 
	AVFrame *frame;
	frame = av_frame_alloc();
	if (!frame)
	{
		return -1;
	}
 
	/* initialize packet, set data to NULL, let the demuxer fill it */
	AVPacket pkt;
	av_init_packet(&pkt);
	pkt.data = NULL;
	pkt.size = 0;
 
	int got_frame;
 
	int width_dst = width_src / 3;
	int height_dst = height_src / 3;
 
	SwsContext *img_convert_ctx = sws_getContext(width_src, height_src, pix_fmt_src, width_dst, height_dst, AV_PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
 
	CDC *pDC = pDlg->GetDC();
	HDC hDC = *pDC;
	HDC hDCMem = CreateCompatibleDC(hDC);
 
	BYTE* pbmpData = NULL;
 
	BITMAPINFO bmi = { 0 };
	bmi.bmiHeader.biBitCount = 24;
	bmi.bmiHeader.biCompression = BI_RGB;
	bmi.bmiHeader.biHeight = -height_src;
	bmi.bmiHeader.biWidth = width_src;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biSizeImage = height_src * width_src * 3;
	hbmp = CreateDIBSection(hDCMem, &bmi, DIB_RGB_COLORS, (LPVOID *)&pbmpData, NULL, 0);
 
 
	timeBase = (int64_t(video_dec_ctx->time_base.num) * AV_TIME_BASE) / int64_t(video_dec_ctx->time_base.den);
 
	int cmpFrame = 1;
	int64_t seekTarget = int64_t(cmpFrame) * timeBase;
 
 
	/* read frames from the file */
	while (av_read_frame(fmt_ctx, &pkt) >= 0)
	{
		cmpFrame = cmpFrame + 5;
		seekTarget = int64_t(cmpFrame) * timeBase;
		AVPacket orig_pkt = pkt;
		do
		{
			got_frame = 0;
			ret = avcodec_decode_video2(video_dec_ctx, frame, &got_frame, &pkt);
			if (ret < 0)
			{
				return -1;
			}
			if (got_frame)
			{
				if (frame->width != width_src || frame->height != height_src ||
					frame->format != pix_fmt_src)
				{
					return -1;
				}
			}
 
			av_image_copy(video_tmp_data, video_tmp_linesize,
			(const uint8_t **)(frame->data), frame->linesize,
			pix_fmt_src, width_src, height_src);
 
			sws_scale(img_convert_ctx, video_tmp_data, video_tmp_linesize, 0, height_src, video_dst_data, video_dst_linesize);
 
			EnterCriticalSection(&csBitMap);
			video_dst_data[0] = (uint8_t*)pbmpData;
			video_dst_linesize[0] = width_src * 3;
			SelectObject(hDCMem, hbmp);
			BitBlt(hDC, 0, 0, width_src, height_src, hDCMem, 0, 0, SRCCOPY);
			//pDlg->m_BMP.SetBitmap(hbmp);
			LeaveCriticalSection(&csBitMap);
 
			//fwrite(video_dst_data[0], 1, video_dst_bufsize, video_dst_file);
 
			if (ret < 0)
				break;
			pkt.data += ret;
			pkt.size -= ret;
		} while (pkt.size > 0);
		av_packet_unref(&orig_pkt);
	}
 
	char Output[200];
	sprintf(Output, "Play the output video file with the command:\n"
		"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d\n",
		av_get_pix_fmt_name(pix_fmt_src), width_src, height_src);

merci d'avance.

[koala01]

Salut,

Je n'ai jamais utilisé ffmpeg (comme tant d'autres bibliothèques d'ailleurs ) et je ne pourrai donc pas t'aider sur les problèmes qui lui sont propres, mais :

1. une fonction de plus de 200 lignes, c'est une fonction qui est -- au minimum -- quatre fois trop grande. Et ca, ca signifie -- en très gros -- que ta fonction fait au minimum... quatre fois trop de choses. Je reviendrai là dessus plus tard
2. En C++, on va veiller à déclarer les variables au plus près de leur première utilisation, c'est d'autant plus vrai lorsqu'il s'agit de pointeurs, qui risquent de garder une valeurs null et auxquels on risque donc d'essayer d'accéder de manière éhontée.
3. L'utilisation de pointeurs pose énormément de problèmes, qui font que l'on conseille généralement au débutant de les éviter autant que possible et que, quand on s'habitue, on souhaite ne pas les utiliser quand ce n'est pas nécessaire
4. Une partie des problèmes liés à l'utilisation des pointeurs vient du fait que C++ est un langage à exception, et que la levée d'une exception pose énormément de problèmes quant à la libération des ressources, dont la mémoire allouée de manière dynamique. Depuis C++11, nous disposons de pointeurs intelligents qui rendent la gestion de ces ressources bien plus facile à mettre en place, il est primordial de les utiliser
5. Ton code ressemble bien plus à du C qu'à du C++. S'il est vrai que C++ supporte une partie des fonctionnalités du C, il y a -- malgré tout -- une bonne partie du C qui n'est pas supportée, car en contradiction avec des règles que C++ juge primordiale. Tu devras donc faire un choix: soit, tu veux utiliser C++, mais il faudra adapter très largement ton code à ce langage, soit tu veux utiliser C, mais, dans ce cas, le déplacement de la discussion dans la rubrique ad-hoc devrait être demandé aux modérateurs
6. Quand du code est inutile, supprimes le complètement (au besoin utilises un système de gestion de versions concurrentes pour garder l'historique des modifications ) au lieu de "simplement" le commenter... Les commentaire de ce styles ne sont que du bruit qui tend à rendre la compréhension du code plus difficile qu'elle ne devrait l'être

Pour te permettre de comprendre ma première remarque, si on observe le code que tu nous donnes, et que l'on ignore les déclarations que l'on trouve jusqu'à la ligne 14, on remarque

1. que de la ligne 14 à la ligne 25, tu cherches à te connecter à ta camera;
2. que de la ligne 26 à la ligne 31, tu essayes de récupérer les informations relatives au flux envoyé par ta caméra;
3. que de la ligne 33 à la ligne 78, tu essayes de définir le meilleur format de récupération des données
4. que de la ligne 79 à la ligne 163, tu essaye de créer les différentes données dont tu vas avoir besoin. Et je soupçonne très fortement que je pourrais trouver *** assez facilement *** trois ou quatre processus distincts dans cette explication
5. que de la ligne 165 à la ligne 209, tu essayes de récupérer (et de convertir "à la volée") le flux de données auquel tu as accès
6. de la ligne 211 à la ligne 214, tu provoque un affichage final

Si je compte bien, ta fonction prend donc en charge six responsabilités différentes. Sept si l'on considère que le (5) correspond à deux responsabilités distinctes (récupération des données d'une part et conversion des données de l'autres), et sans doute encore bien plus si, comme je le soupçonnes, le (4) regroupe lui aussi plusieurs responsabilités distinctes.

Or, une fonction qui prend six responsabilités en charge, c'est une fonction qui en prend... cinq de trop!!!

La première chose que tu devrais faire que ce soit en C ou en C++, c'est de subdiviser cette fonction en "autant de fonctions qu'il faudra" pour que chaque fonction ne s'occupe que d'une seule et unique chose, ce qui te permettra de t'assurer que chaque fonction fasse correctement ce qu'elle est sensée faire (entre autres, à l'aide de tests unitaires, par exemple )

Une fois que tu auras ces cinq, six, sept ou dix fonctions clairement distinctes, il ne te restera plus qu'à... les appeler dans l'ordre logique dans lequel elles doivent être exécutées pour obtenir le résultat escompté.

Cela peut sembler représenter un travail important pour finalement "pas grand chose", mais je peux t'assurer que ce travail que tu pourrais juger "inutile" t'évitera de perdre beaucoup plus de temps par la suite

[frezze]

bonjour,

Je prends note de tes remarques et je vais voir pour faire une découpe en fonction, mais ce code que j'ai mis est qu'un simple test que j'ai fait en m'inspirent de différents exemples pour voir quelle méthode de la librairie FFmpeg je dois utiliser, les qu'elles sont les plus adapter, ... peut-être que j'utilise les "mauvaises " méthodes ou que je les utilises mal. Et c'est vrai que je n'ai peut-être pas posté ma question dans la bonne rubrique mais j'en ai pas trouvé à plus approprier.

[koala01]

Bon, la première question à te poser est donc: veux tu travailler en C ou en C++

Pour t'aider à y répondre, vu que c'est pour faire un wrapper vers C# par la suite, il faut prendre en compte

1. Le fait que C est la "langae franca" de la programmation: c'est le plus petit commun multiple de tous les langages, et qu'il est donc -- a priori -- bien plus facile de créer une dll C qui sera wrappée dans les autres langages
2. Le fait que C++ peut -- s'il est bien utilisé (ce qui est loin d'être le cas dans ton code) -- apporter énormément de facilités et de sécurité par rapport au C, et ce, à différents points de vue
3. Le fait que, si tu veux partir vers du développement C#, C++ présente l'inconvénient d'occasionner un "mangling" (une "décoration" du nom) des fonctions, et qu'une interface extern "C" sera sans doute utile (mais complexifiera sans doute le développement d'autant)

[frezze]

salut,

je me suis encore mal exprimé ( sorry ) et surtout oublier de dire qu'en réalité je ne compte pas écrire une .dll car ils sont déjà faits et donc moi je compte juste les utiliser

les .dll utilisées sont :

• avcodec-58.dll
  avutil-56.dll
  avformat-58.dll
  swscale-5.dll
  avfilter-7.dll
  avdevice-58.dll
  

Ces .dll sont écrits en C et je les aie DL sur le site officiel de FFmpeg https://ffmpeg.zeranoe.com/builds/
j'ai essayé avec l'architecture 64 et 32 bit de la dernière version qu'il propose et j'ai eu le même problème.

Au début je compter faire mon warpper en c++ car c'est ce que on m'as conseiller mais vue que mes .dll sont en C faire le warpper en C sera plus simple ( pas sure)
mais je compte pas encore écrire un warpper tant que je ne saurais pas utiliser correctement ces .dll.

ce que je ne comprends pas c'est que je me suis basée sur des exemples officiels, et tous les codes que j'ai trouvés lors de mes recherches étaient similaire à mon code ( normale vue qu'ont utilisée les mêmes .dll)
De plus j'ai aucun problème (frezze ) pendant 3-5 seconde

J'ai pu corriger le fait que ma couleur était mal affichée, cela venait du fait que je changer le format de mon image en RGB24 mais je devais le changer en BGR24.