comparison sv/videoio/SDL_ffmpeg.cpp @ 129:587ad94d6ac2

(none)

 #endif
 #ifdef WIN32
 #include "SDL_ffmpeg.h"
 #include <SDL.h>
 #include <SDL_thread.h>
+#include <stdio.h>
+#include <Windows.h>
 #endif
 
 #ifdef __unix__
 #include <SDL/SDL.h>
 #include <SDL/SDL_thread.h>
 #endif
 #ifdef __cplusplus
 }
 #endif
 #include "../../sv/main/MainWindow.h"
+#include <time.h>
 
 //const int SDL_FFMPEG_MAX_BUFFERED_FRAMES = 25;
 //const int SDL_FFMPEG_MAX_BUFFERED_SAMPLES = 512 * 512;
-
+extern float hopfactor;
 int FFMPEG_init_was_called = 0;
-
+FILE *pFile, *tFile;
+int64_t Time,Time1;
+int64_t realt=0;
+  
 SDL_ffmpegFile* SDL_ffmpegCreateFile() {
 
     // create SDL_ffmpegFile pointer
     SDL_ffmpegFile *file = (SDL_ffmpegFile*)malloc( sizeof(SDL_ffmpegFile) );
     if(!file) return 0;
 	file->_ffmpeg=av_alloc_format_context();//(AVFormatContext*)malloc(sizeof(AVFormatContext));
     // create a semaphore for every file
     file->decode = SDL_CreateSemaphore(1);
 
+	Time=0;
+	Time1=0;
+   fopen_s (&pFile,"myfile.txt","w");
+	 fopen_s (&tFile,"Timestampfile.txt","w");
     // allocate room for VStreams
     file->vs = (SDL_ffmpegStream**)malloc( sizeof(SDL_ffmpegStream*) * MAX_STREAMS );
     if(!file->vs) {
         free( file );
         return 0;

                     memcpy(stream->codecName, ((AVFormatContext*)file->_ffmpeg)->streams[i]->codec->codec_name, 32);
 
                     stream->audio = 0;
                     stream->size = 0;
                     stream->imageBuffer = (bufferImage**)calloc( SDL_FFMPEG_MAX_BUFFERED_FRAMES, sizeof(bufferImage*) );
-
+					stream->writeImage = 0;
+					stream->readImage = 0;
                     file->vs[file->VStreams] = stream;
                     file->VStreams++;
 
                     // create semaphore for thread-safe use
                     stream->sem = SDL_CreateSemaphore(1);

     if( !SDL_ffmpegValidVideo(file) || file->pause || file->skipVideo) return 0;
 
     SDL_SemWait(file->vs[file->videoStream]->sem);
 
     bufferImage *option = 0;
-    int i;
-
-    for(i=0; i<SDL_FFMPEG_MAX_BUFFERED_FRAMES; i++) {
-
+    //int i;
+	float ratio;
+	int64_t pos,pos1, pos2, timestamp;
+    //for(i=0; i<SDL_FFMPEG_MAX_BUFFERED_FRAMES; i++) {
+		pos=MWinsA->Get_CurAudioTime();
+
+		fprintf (pFile, "p: \t %u\t", pos);
+		//if (MWinsA->Get_HardwareBufferTime()==0)
+		//	pos1=0;
+		//else {
+		//	pos1=MWinsA->Get_HardwareBufferTime();
+		//	//fprintf (tFile, "%u\t", pos1);
+		//	int64_t timeTemp;
+		//	QueryPerformanceCounter((LARGE_INTEGER *)(&timeTemp));
+		//	
+		//	pos1=(timeTemp-pos1)/(file->countFreq*hopfactor);
+		//	fprintf (pFile, "%u\t", pos1);
+		//}
+		//pos2=pos+pos1;
+		fprintf (pFile, "%u\n", pos);
+		
         // if this entry does not exist, continue
-        if(!file->vs[file->videoStream]->imageBuffer[i]) continue;
-		
-
-		int64_t pos=MWinsA->Get_CurAudioTime();
-        // do we have an image that should have been shown?
-        if(file->vs[file->videoStream]->imageBuffer[i]->timestamp <= pos + ((AVFormatContext*)file->_ffmpeg)->start_time/1000) {
-
-            // if this is the first option we find, we simply save it
-            if(!option) {
-
-                option = file->vs[file->videoStream]->imageBuffer[i];
-
-                // set to 0 so we know this position in the buffer is available again
-                file->vs[file->videoStream]->imageBuffer[i] = 0;
-
-            } else {
-
-                // we found a newer possible timestamp, we delete the older one
-                if( option->timestamp < file->vs[file->videoStream]->imageBuffer[i]->timestamp) {
-
-                    // this image is too old, we discard it
-                    SDL_FreeSurface( option->img );
-
-                    // free old option
-                    free( option );
-
-                    // new pointer to position in container
-                    option = file->vs[file->videoStream]->imageBuffer[i];
-
-                    // set to 0 so we know this position in the buffer is available again
-                    file->vs[file->videoStream]->imageBuffer[i] = 0;
-                }
-            }
-        }
-    }
-
+        while(((file->vs[file->videoStream]->writeImage - file->vs[file->videoStream]->readImage)>0)&&(file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES]->timestamp <= pos + ((AVFormatContext*)file->_ffmpeg)->start_time/1000))//&& (file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES]->timestamp >= pos - file->timebase+ ((AVFormatContext*)file->_ffmpeg)->start_time/1000)) 
+		{
+			//pos=MWinsA->Get_CurAudioTime();
+			//timestamp=file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES]->timestamp;
+			//fprintf (tFile, "try: %d	%d\n", (pos+ ((AVFormatContext*)file->_ffmpeg)->start_time/1000), timestamp);
+			// do we have an image that should have been shown?
+			//if(file->vs[file->videoStream]->imageBuffer[mod(file->vs[file->videoStream]->readImage,SDL_FFMPEG_MAX_BUFFERED_FRAMES)]->timestamp <= pos + (file->vs[file->videoStream]->timeBase)/4+((AVFormatContext*)file->_ffmpeg)->start_time/1000) {
+				
+				// if this is the first option we find, we simply save it
+				if(!option) {
+
+					option = file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES];
+
+					// set to 0 so we know this position in the buffer is available again
+					file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES] = 0;
+					file->vs[file->videoStream]->readImage++;
+
+				} else {
+
+					// we found a newer possible timestamp, we delete the older one
+					if( option->timestamp < file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES]->timestamp) {
+
+						// this image is too old, we discard it
+						SDL_FreeSurface( option->img );
+
+						// free old option
+						free( option );
+
+						// new pointer to position in container
+						option = file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES];
+
+						// set to 0 so we know this position in the buffer is available again
+						file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES] = 0;
+						file->vs[file->videoStream]->readImage++;
+					}
+					else {
+						file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->readImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES]=0;
+						file->vs[file->videoStream]->readImage++;
+					}
+				}
+
+				
+				pos=MWinsA->Get_CurAudioTime();	
+				fprintf (pFile, "e:\t%u\t", pos);
+				//if (MWinsA->Get_HardwareBufferTime()==0)
+				//	pos1=0;
+				//else {
+				//	pos1=MWinsA->Get_HardwareBufferTime();
+				//	//fprintf (tFile, "%u\t", pos1);
+				//	int64_t timeTemp;
+				//	QueryPerformanceCounter((LARGE_INTEGER *)(&timeTemp));
+			
+				//	pos1=(timeTemp-pos1)/(file->countFreq*hopfactor);
+				//	fprintf (pFile, "%u\t", pos1);
+				//}
+				//fprintf (pFile, "%u\n", pos2);
+				//pos2=pos+pos1;
+				//if (pos<pos2) pos=pos2;
+		}
+		//}
+	//}
+	int x=file->vs[file->videoStream]->writeImage - file->vs[file->videoStream]->readImage;
     // if we did not found an option, we exit
     if(!option) {
         // release the lock
+		/*timestamp=0;
+		int64_t tt=av_gettime()/1000-file->timer;
+		file->timer=av_gettime()/1000;
+		realt+=tt;
+		fprintf (tFile, "%u\t", realt);
+		fprintf (tFile, "%u\t", tt);
+		fprintf (tFile, "%u\t", pos);
+		fprintf (tFile, "%u\n", timestamp);*/
         SDL_SemPost(file->vs[file->videoStream]->sem);
         return 0;
     }
-
+	int64_t tt;
+	QueryPerformanceCounter((LARGE_INTEGER *)(&tt));
+	tt=tt/(file->countFreq)-file->timer;
+	
+	QueryPerformanceCounter((LARGE_INTEGER *)(&file->timer));
+	file->timer=file->timer/(file->countFreq);
+	realt+=tt;
+	fprintf (tFile, "%u\t", x);
+	fprintf (tFile, "%u\t", realt);
+	fprintf (tFile, "%u\t", tt);
+	timestamp=(pos-option->timestamp+((AVFormatContext*)file->_ffmpeg)->start_time/1000)/hopfactor;	
+	fprintf (tFile, "%u\t", pos);//+ (file->vs[file->videoStream]->timeBase)/4+((AVFormatContext*)file->_ffmpeg)->start_time/1000);
+	fprintf (tFile, "%d\n", timestamp);
     // we did found an option, so we return the imagedata
     return option->img;
 }
 
 int SDL_ffmpegReleaseVideo(SDL_ffmpegFile *file, SDL_Surface *bmp) {

 
         // If it's a video packet from our video stream...
         if( SDL_ffmpegValidVideo(file) && pack.stream_index == file->vs[file->videoStream]->id && !file->skipVideo) {
 
             got_frame = 0;
-
+//Time1=av_gettime();
             // Decode the packet
             avcodec_decode_video((AVCodecContext *)(file->vs[file->videoStream]->_ffmpeg), inFrame, &got_frame, pack.data, pack.size);
 
             if(got_frame) {
 

                         24, 0x0000FF, 0x00FF00, 0xFF0000, 0);
 
                     // copy image data to image room
                     memcpy(buf->img->pixels, inFrameRGB->data[0],
                         file->vs[file->videoStream]->width * file->vs[file->videoStream]->height * 3);
-
+					file->timebase=buf->timestamp-file->vs[file->videoStream]->lastTimeStamp;
                     // we write the lastTimestamp we got
                     file->vs[file->videoStream]->lastTimeStamp = buf->timestamp;
 
-                    int i;
+                    //int i;
                     int again = 1;
-
+//Time=av_gettime()-Time1;
+
+//fprintf (pFile, "%d	\n",Time);
                     // keep trying to fit in buffer, until the data was actually placed in the buffer
                     while(again && file->threadActive) {
 
                         // we enter the video semaphore
                         SDL_SemWait(file->vs[file->videoStream]->sem);
 
                             // loop through all positions in buffer until an empty
                             // space was found
-                            for(i=0; i<SDL_FFMPEG_MAX_BUFFERED_FRAMES; i++) {
+                            //for(i=0; i<SDL_FFMPEG_MAX_BUFFERED_FRAMES; i++) {
                                 // if this place in the buffer is empty we write our new frame
-                                if(file->vs[file->videoStream]->imageBuffer[i] == 0) {
-                                    file->vs[file->videoStream]->imageBuffer[i] = buf;
+                                if((file->vs[file->videoStream]->writeImage - file->vs[file->videoStream]->readImage) < SDL_FFMPEG_MAX_BUFFERED_FRAMES) {
+                                    file->vs[file->videoStream]->imageBuffer[file->vs[file->videoStream]->writeImage%SDL_FFMPEG_MAX_BUFFERED_FRAMES] = buf;
+									file->vs[file->videoStream]->writeImage++;
                                     // we placed our image in the buffer, moving on
                                     again = 0;
-                                    break;
+                                    
                                 }
-                            }
+                            //}
 
                         // we leave the video semaphore
                         SDL_SemPost(file->vs[file->videoStream]->sem);
-
+						
                         // frames aren't being release every ms, so we can take some
                         // time before we try and fit our new image again
-                        if(again) SDL_Delay(5);
+                        if(again) 
+						{
+							SDL_SemPost(file->decode);
+							SDL_Delay(3);
+							SDL_SemWait(file->decode);
+						}
                     }
     //            } 
 				//else {
     //                // if our decoded frame was too old, we don't bother putting
     //                // it in our buffer

                 free( file->vs[file->videoStream]->imageBuffer[i] );
 
                 // set position in buffer to 0, so we know it is empty
                 file->vs[file->videoStream]->imageBuffer[i] = 0;
             }
-
+			file->vs[file->videoStream]->writeImage=0;
+			file->vs[file->videoStream]->readImage=0;
         SDL_SemPost(file->vs[file->videoStream]->sem);
     }
 
     return 0;
 }