PeerStreamer

#undef main /* Prevents SDL from overriding main() */

#endif

#include "chunker_player.h"

#define SDL_AUDIO_BUFFER_SIZE 1024

#define AUDIO	1

#define VIDEO	2

short int QueueFillingMode=1;

short int QueueStopped=0;

	SDL_cond *cond;

	short int queueType;

	int last_frame_extracted;

} PacketQueue;

typedef struct threadVal {

	q->cond = SDL_CreateCond();

	QueueFillingMode=1;

	q->queueType=Type;

}

int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

			if(q->nb_packets>=QUEUE_FILLING_THRESHOLD && QueueFillingMode) // && q->queueType==AUDIO)

			{

				QueueFillingMode=0;

				//SDL_CondSignal(q->cond);

			}

		}

	}

		if(av==1) {

			if(pkt1->pkt.size-AudioQueueOffset>dimAudioQ) {

#ifdef DEBUG_QUEUE

#endif

				//av_init_packet(&tmp);

				q->size -= dimAudioQ;

				memcpy(pkt->data,pkt1->pkt.data+AudioQueueOffset,dimAudioQ);

				pkt->dts = pkt1->pkt.dts;

				pkt->pts = pkt1->pkt.pts;

				pkt->flags = 1;

				pkt->pos = -1;

				pkt->convergence_duration = -1;

				pkt1->pkt.pts += deltaAudioQ;

				AudioQueueOffset += dimAudioQ;

#ifdef DEBUG_QUEUE

#endif

				ret = 1;

				q->last_frame_extracted = pkt->stream_index;

			}

			else {

#ifdef DEBUG_QUEUE

#endif

				// Check for loss

				if(pkt1->next)

				{

					//av_init_packet(&tmp);

					pkt->size = dimAudioQ;

					pkt->dts = pkt1->pkt.dts;

					pkt->pts = pkt1->pkt.pts;

					pkt->flags = 1;

					pkt->pos = -1;

					pkt->convergence_duration = -1;

					{

						SizeToCopy=pkt1->pkt.size-AudioQueueOffset;

#ifdef DEBUG_QUEUE

#endif

						memcpy(pkt->data,pkt1->pkt.data+AudioQueueOffset,SizeToCopy);

						memcpy(pkt->data+SizeToCopy,pkt1->next->pkt.data,(dimAudioQ-SizeToCopy)*sizeof(uint8_t));

					q->last_pkt = NULL;

				q->nb_packets--;

				q->size -= SizeToCopy;

				free(pkt1->pkt.data);

				av_free(pkt1);

				// Adjust timestamps

				pkt1 = q->first_pkt;

				if(pkt1)

					AudioQueueOffset=0;

				}

#ifdef DEBUG_QUEUE

#endif

				q->last_frame_extracted = pkt->stream_index;

			}

		}

		else {

			q->first_pkt = pkt1->next;

			if (!q->first_pkt)

				q->last_pkt = NULL;

			pkt->pos = pkt1->pkt.pos;

			pkt->convergence_duration = pkt1->pkt.convergence_duration;

			//*pkt = pkt1->pkt;

			memcpy(pkt->data,pkt1->pkt.data,pkt1->pkt.size);

			free(pkt1->pkt.data);

			av_free(pkt1);

			ret = 1;

			q->last_frame_extracted = pkt->stream_index;

		}

	}

		QueueFillingMode=1;

	SDL_UnlockMutex(q->mutex);

	return ret;

			FirstTimeAudio = 0;

			FirstTime = 0;

#ifdef DEBUG_AUDIO 

#endif

		}

	}

	pCodecCtx=avcodec_alloc_context();

        pCodecCtx->codec_type = CODEC_TYPE_VIDEO;

        pCodecCtx->codec_id  = CODEC_ID_H264;

        pCodecCtx->max_qdiff = 4;

        pCodecCtx->qmin = 10;

        pCodecCtx->qmax = 51;

        pCodecCtx->qcompress = 0.6;

        // resolution must be a multiple of two

        pCodecCtx->width = tval->width;//176;//352;

        pCodecCtx->height = tval->height;//144;//288;

        // frames per second

        pCodecCtx->pix_fmt = PIX_FMT_YUV420P;

        pCodec=avcodec_find_decoder(pCodecCtx->codec_id);

				avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &VideoPkt);

					//SaveFrame(pFrame, pCodecCtx->width, pCodecCtx->height, cont++);

					//fwrite(pktvideo.data, 1, pktvideo.size, frecon);

                        		// Lock SDL_yuv_overlay

	                        	if ( SDL_MUSTLOCK(screen) ) {

                	        	}

                        		if (SDL_LockYUVOverlay(yuv_overlay) < 0) break;

	                        	pict.data[0] = yuv_overlay->pixels[0];

        	                	pict.data[1] = yuv_overlay->pixels[2];

                        		pict.linesize[0] = yuv_overlay->pitches[0];

	                        	pict.linesize[1] = yuv_overlay->pitches[2];

        	                	pict.linesize[2] = yuv_overlay->pitches[1];

                	        	img_convert_ctx = sws_getContext(tval->width,tval->height,PIX_FMT_YUV420P,tval->width,tval->height,PIX_FMT_YUV420P,SWS_BICUBIC,NULL,NULL,NULL);

	                        	if(img_convert_ctx==NULL) {

		                        	fprintf(stderr,"Cannot initialize the conversion context!\n");

        		                        exit(1);

                        		}

	                        	sws_scale(img_convert_ctx,pFrame->data,pFrame->linesize,0,tval->height,pict.data,pict.linesize);

		                        // let's draw the data (*yuv[3]) on a SDL screen (*screen)

        	                	if ( SDL_MUSTLOCK(screen) ) {

			                        SDL_UnlockSurface(screen);

                        		}

                        		SDL_UnlockYUVOverlay(yuv_overlay);

	                        	// Show, baby, show!

        	                	SDL_DisplayYUVOverlay(yuv_overlay, &rect);

				}

			}

	int frameFinished, len_audio;

	int numBytes,outbuf_audio_size,audio_size;

	uint8_t *outbuf,*outbuf_audio;

	uint8_t *outbuf_audi_audio;

	//SDL_mutex   *lock;

	SDL_AudioSpec wanted_spec, spec;

	char buf[1024],outfile[1024], basereadfile[1024],readfile[1024];

	FILE *fp;	

	int width,height,asample_rate,achannels;

	//double framerate;

	ThreadVal *tval;

	tval = (ThreadVal *)malloc(sizeof(ThreadVal));

	//aCodecCtx->bit_rate = 64000;

	aCodecCtx->sample_rate = asample_rate;

	aCodecCtx->channels = achannels;

	aCodec = avcodec_find_decoder(CODEC_ID_MP3); // codec audio

	if(!aCodec) {

		printf("Codec not found!\n");

		return -1;

		fprintf(stderr, "could not open codec\n");

		return -1; // Could not open codec

	}

	wanted_spec.freq = aCodecCtx->sample_rate;

	wanted_spec.format = AUDIO_S16SYS;

	wanted_spec.channels = aCodecCtx->channels;

		exit(1);

	}

	yuv_overlay = SDL_CreateYUVOverlay(width, height,SDL_YV12_OVERLAY, screen);

	if ( yuv_overlay == NULL ) {

	//lock = SDL_CreateMutex();

	//SDL_WaitThread(exit_thread2,NULL);

	}

	// Stop audio&video playback

	SDL_WaitThread(video_thread,NULL);

	SDL_PauseAudio(1);

	SDL_CloseAudio();

	SDL_Quit();

	//SDL_DestroyMutex(lock);

	av_free(aCodecCtx);

	free(AudioPkt.data);

	free(VideoPkt.data);

  free(outbuf_audio);

	return 0;

}

	Frame *frame=NULL;

	AVPacket packet, packetaudio;

	int16_t *dataQ;

	int data_sizeQ;

	int lenQ;

	int sizeFrame = 0;

	sizeFrame = 3*sizeof(int)+sizeof(struct timeval);

	gchunk = (Chunk *)malloc(sizeof(Chunk));

	if(!gchunk) {

		return PLAYER_FAIL_RETURN;

	}

  decodeChunk(gchunk, block, block_size);

	echunk = grapesChunkToExternalChunk(gchunk);

  free(gchunk);

	frame = (Frame *)malloc(sizeof(Frame));

			if(frame->type!=5) { // video frame

				av_init_packet(&packet);

#ifdef DEBUG_SOURCE

#endif

			}

			else { // audio frame

				av_init_packet(&packetaudio);

				// insert the audio frame into the queue

				data_sizeQ = AVCODEC_MAX_AUDIO_FRAME_SIZE;

				if(lenQ>0)

				{

					// for freeing there is some memory still in tempdata to be freed

					if(dataQ)

					{

						memcpy(dataQ,audio_bufQ,data_sizeQ);

		}

		ProcessKeys();

*/

	free(echunk);

	free(frame);

}

#include <SDL_thread.h>

#include "chunker_streamer.h"

#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

	AVFrame         *pFrame; 

	AVFrame         *pFrameRGB;

	AVPacket         packet;

	Frame *frame=NULL;

	long long Now;

	short int FirstTimeAudio=1, FirstTimeVideo=1;

	long long DeltaTimeAudio=0, DeltaTimeVideo=0, newTime;

	struct dirent **namelist;

	cmeta = chunkerInit("configChunker.txt");

	dir_entries = scandir("chunks",&namelist,NULL,alphasortNew);

	if(dir_entries>0) {

		strcpy(basedelfile,"chunks/");

		rmdir("chunks");

	}

	mkdir("chunks",0777);

	fprintf(stderr, "Chunkbuffer Strategy:%d Value Strategy:%d\n", cmeta->strategy, cmeta->val_strategy);

	f1 = fopen("original.mpg","wb");

	// Find the first video stream

	videoStream=-1;

	audioStream=-1;

	for(i=0; i<pFormatCtx->nb_streams; i++) {

		if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO && videoStream<0) {

			videoStream=i;

			audioStream=i;

		}

	}

	fprintf(stderr, "Video stream has id : %d\n",videoStream);

	fprintf(stderr, "Audio stream has id : %d\n",audioStream);

	pCodecCtxEnc=avcodec_alloc_context();

	pCodecCtxEnc->me_range=16;

	pCodecCtxEnc->max_qdiff=4;

	pCodecCtxEnc->qmin=10;

	pCodecCtxEnc->height = pCodecCtx->height;

	// frames per second 

	pCodecCtxEnc->time_base= pCodecCtx->time_base;//(AVRational){1,25};

	pCodecCtxEnc->gop_size = 10; // emit one intra frame every ten frames 

	//pCodecCtxEnc->max_b_frames=1;

	pCodecCtxEnc->pix_fmt = PIX_FMT_YUV420P;

	aCodecCtxEnc = avcodec_alloc_context();

	aCodecCtxEnc->bit_rate = audio_bitrate; //256000

	if(audioStream!=-1) {

		aCodec = avcodec_find_decoder(aCodecCtx->codec_id);

		aCodecEnc = avcodec_find_encoder(CODEC_ID_MP3);

		if(aCodec==NULL) {

			fprintf(stderr,"Unsupported acodec!\n");

			return -1;

		}

	}

	if(pCodec==NULL) {

		fprintf(stderr, "Unsupported pcodec!\n");

		return -1; // Codec not found

		return -1;

	}

	sizeChunk = 6*sizeof(int)+2*sizeof(struct timeval)+sizeof(double);

	initChunk(chunk,&seq_current_chunk);

	chunkaudio = (ExternalChunk *)malloc(sizeof(ExternalChunk));

	if(!chunkaudio) {

		fprintf(stderr, "Memory error!!!\n");

		return -1;

	}

	initChunk(chunkaudio,&seq_current_chunk);

	stime = -1;

		// Is this a packet from the video stream?

		if(packet.stream_index==videoStream) {

			// Decode video frame

#ifdef DEBUG_VIDEO_FRAMES

#endif

				// Did we get a video frame?

				//stime = (int)packet.dts;

				if(frameFinished) { // it must be true all the time else error

					frame->number = contFrameVideo++;//pCodecCtx->frame_number;

					Now=(long long)SDL_GetTicks();

#ifdef DEBUG_VIDEO_FRAMES

#endif

						newtimestamp = ((double)((packet.dts)*pCodecCtxEnc->time_base.num))/((double)(packet.duration*(pCodecCtxEnc->time_base.den)));

					else

						newtimestamp =((double)((packet.dts)*pCodecCtxEnc->time_base.num)/((double)pCodecCtxEnc->time_base.den));

					//frame->timestamp.tv_sec = (long)packet.dts*1.e-5;

					//frame->timestamp.tv_usec = ((long)packet.dts%100000/100);

					//fprintf(stderr, "ts:%llf\n",newtimestamp);

#endif

					if(FirstTimeVideo) {

						DeltaTimeVideo=Now-((unsigned int)newtimestamp*(unsigned long long)1000+(newtimestamp-(unsigned int)newtimestamp)*1000);

						FirstTimeVideo = 0;

#ifdef DEBUG_VIDEO_FRAMES

						//fprintf(stderr, "DeltaTimeVideo : %lld\n",DeltaTimeVideo);

#endif

					}

					newTime = DeltaTimeVideo+((unsigned int)newtimestamp*(unsigned long long)1000+(newtimestamp-(unsigned int)newtimestamp)*1000);

					}

					frame->timestamp.tv_usec = newTime%1000;

					frame->size = out_size;

					frame->type = pFrame->pict_type;

#ifdef DEBUG_VIDEO_FRAMES

					//fprintf(stderr, "video newt:%lf dts:%ld dur:%d sec:%d usec%d pts:%d\n",newtimestamp,(long)packet.dts,packet.duration,frame->timestamp.tv_sec,frame->timestamp.tv_usec,packet.pts);

#endif

					// Save the frame to disk

					++i;

						return -1;

					}

#ifdef DEBUG_VIDEO_FRAMES

					//fprintf(stderr, "rialloco data di dim:%d con nuova dim:%d\n",chunk->payload_len,out_size);

#endif

					tempdata = chunk->data+chunk->payload_len;

					*((int *)tempdata) = frame->number;

					tempdata+=sizeof(int);

					fwrite(outbuf, 1, out_size, f1); // reconstructing original video

				}

			}

		}

		else if(packet.stream_index==audioStream) {

#ifdef DEBUG_AUDIO_FRAMES

			//fprintf(stderr, "packet audio dts:%d dts:%d\n",(int)packet.dts,(int)packet.dts);

			data_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;

			if(avcodec_decode_audio3(aCodecCtx, audio_buf, &data_size, &packet)>0) {

#ifdef DEBUG_AUDIO_FRAMES

#endif

				if(data_size>0) {

#ifdef DEBUG_AUDIO_FRAMES

#endif

				}

				audio_size = avcodec_encode_audio(aCodecCtxEnc,outbuf_audio,data_size,audio_buf);

#ifdef DEBUG_AUDIO_FRAMES

				//fprintf(stderr, "audio frame size nuovo pippo : %d %d datasize:%d %d %d\n",aCodecCtxEnc->frame_size,aCodecCtxEnc->time_base.den,data_size,packet.size, len1);

				//fprintf(stderr, "oldaudiosize:%d Audio size : %d\n",len1,audio_size);

				//fprintf(stderr, "stream_index:%d flags:%d pos:%d conv_duration:%d dts:%d dts:%d duration:%d\n",packet.stream_index,packet.flags,packet.pos,packet.convergence_duration,packet.dts,packet.dts,packet.duration);

#endif				

				frame->number = contFrameAudio++;//aCodecCtx->frame_number;

				//newtimestamp = (double)((float)packet.dts/(packet.duration*34.100));

				Now=(long long)SDL_GetTicks();

				if(packet.duration>0)

					newtimestamp = ((double)((packet.dts)*aCodecCtxEnc->time_base.num))/((double)(packet.duration*(aCodecCtxEnc->time_base.den)));

				else

					newtimestamp =((double)((packet.dts)*aCodecCtxEnc->time_base.num)/((double)aCodecCtxEnc->time_base.den));

#ifdef DEBUG_AUDIO_FRAMES

				//frame->timestamp.tv_sec = (long)packet.dts*1.e-5;

				//frame->timestamp.tv_usec = ((long)packet.dts%100000/100);

				if(FirstTimeAudio) {

					DeltaTimeAudio=Now-((unsigned int)newtimestamp*(unsigned long long)1000+(newtimestamp-(unsigned int)newtimestamp)*1000);

					FirstTimeAudio = 0;

				}

				newTime = DeltaTimeAudio+((unsigned int)newtimestamp*(unsigned long long)1000+(newtimestamp-(unsigned int)newtimestamp)*1000);

#ifdef DEBUG_AUDIO_FRAMES

				//fprintf(stderr, "%lld %lld\n",newTime/1000,newTime%1000);

#endif

				}

				frame->timestamp.tv_sec = (unsigned int)newTime/1000;

				frame->timestamp.tv_usec = newTime%1000;

#endif

				//frame->timestamp.tv_sec = (unsigned int)newtimestamp;

				//frame->timestamp.tv_usec = (newtimestamp-frame->timestamp.tv_sec)*1000;

				stime=-1;

				chunkaudio->priority = 1;

#ifdef DEBUG_AUDIO_FRAMES

				//fprintf(stderr, "Frame audio stime:%d frame_num:%d\n",stime,aCodecCtxEnc->frame_number);

				if(chunkFilled(chunkaudio,cmeta)) { // is chunk filled using current strategy?

					//chbAddChunk(chunkbuffer,chunkaudio); // add a chunk to the chunkbuffer

					//SAVE ON FILE

				//fprintf(stderr,"readingQUIPEPPE3\n");

#endif

			}

		}

		else {

#ifdef DEBUG_AUDIO_FRAMES

	// Close the video file

	av_close_input_file(pFormatCtx);

	return 0;

}