Exemple #1
0
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size)
{
    static AVPacket pkt;
    static uint8_t *audio_pkt_data = NULL;
    static int audio_pkt_size = 0;
    int len1, data_size;
    for(;;)
    {
        if(packet_queue_get(audioq, &pkt, 1) < 0)
        {
            return -1;
        }
        audio_pkt_data = pkt.data;
        audio_pkt_size = pkt.size;
        while(audio_pkt_size > 0)
        {
            data_size = buf_size;
            len1 = avcodec_decode_audio2(aCodecCtx, (int16_t *)audio_buf, &data_size,audio_pkt_data, audio_pkt_size);
            if(len1 < 0)
            {
                audio_pkt_size = 0;
                break;
            }
            audio_pkt_data += len1;
            audio_pkt_size -= len1;
            if(data_size <= 0)
            {
                continue;
            }
            return data_size;
        }
        if(pkt.data)
            av_free_packet(&pkt);
   }
}
int video_thread(void *arg) {
        VideoState *is = (VideoState *) arg;
        AVPacket pkt1, *packet = &pkt1;
        //int len1;
        int frameFinished;
        AVFrame *pFrame;

        pFrame = av_frame_alloc();

        for (;;) {
                if (packet_queue_get(&is->videoq, packet, 1) < 0) {
                        // means we quit getting packets
                        break;
                }
                // Decode video frame
                //len1 =
                avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,
                                packet);

                // Did we get a video frame?
                if (frameFinished) {
                        if (queue_picture(is, pFrame) < 0) {
                                break;
                        }
                }
                av_free_packet(packet);
        }
        av_free(pFrame);
        return 0;
}
Exemple #3
0
int audio_decode_frame(VideoState *is, double *pts_ptr) {

    int len1, data_size = 0, n;
    AVPacket *pkt = &is->audio_pkt;
    double pts;

    for (; ;) {
        while (is->audio_pkt_size > 0) {
            int got_frame = 0;
            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame, &got_frame, pkt);
            if (len1 < 0) {
                /* if error, skip frame */
                is->audio_pkt_size = 0;
                break;
            }
            if (got_frame) {
                data_size =
                        av_samples_get_buffer_size
                                (
                                        NULL,
                                        is->audio_st->codec->channels,
                                        is->audio_frame.nb_samples,
                                        is->audio_st->codec->sample_fmt,
                                        1
                                );
                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);
            }
            is->audio_pkt_data += len1;
            is->audio_pkt_size -= len1;
            if (data_size <= 0) {
                /* No data yet, get more frames */
                continue;
            }
            pts = is->audio_clock;
            *pts_ptr = pts;
            n = 2 * is->audio_st->codec->channels;
            is->audio_clock += (double) data_size /
                    (double) (n * is->audio_st->codec->sample_rate);

            /* We have data, return it and come back for more later */
            return data_size;
        }
        if (pkt->data)
            av_free_packet(pkt);

        if (is->quit) {
            return -1;
        }
        /* next packet */
        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {
            return -1;
        }
        is->audio_pkt_data = pkt->data;
        is->audio_pkt_size = pkt->size;
        /* if update, update the audio clock w/pts */
        if (pkt->pts != AV_NOPTS_VALUE) {
            is->audio_clock = av_q2d(is->audio_st->time_base) * pkt->pts;
        }
    }
}
Exemple #4
0
void Player::ScheduleNextFrame(bool prerolling)
{
    AVPacket pkt;
    AVPicture picture;

    if (serial_fd > 0 && packet_queue_get(&dataqueue, &pkt, 0)) {
        if (pkt.data[0] != ' '){
            fprintf(stderr,"written %.*s  \n", pkt.size, pkt.data);
            write(serial_fd, pkt.data, pkt.size);
        }
        av_free_packet(&pkt);
    }

    if (packet_queue_get(&videoqueue, &pkt, 1) < 0)
        return;

    IDeckLinkMutableVideoFrame *videoFrame;
    m_deckLinkOutput->CreateVideoFrame(m_frameWidth,
                                       m_frameHeight,
                                       m_frameWidth * 2,
                                       pix,
                                       bmdFrameFlagDefault,
                                       &videoFrame);
    void *frame;
    int got_picture;
    videoFrame->GetBytes(&frame);

    avcodec_decode_video2(video_st->codec, avframe, &got_picture, &pkt);
    if (got_picture) {
        avpicture_fill(&picture, (uint8_t *)frame, pix_fmt,
                       m_frameWidth, m_frameHeight);

        sws_scale(sws, avframe->data, avframe->linesize, 0, avframe->height,
                  picture.data, picture.linesize);

        if (m_deckLinkOutput->ScheduleVideoFrame(videoFrame,
                                                 pkt.pts *
                                                 video_st->time_base.num,
                                                 pkt.duration *
                                                 video_st->time_base.num,
                                                 video_st->time_base.den) !=
            S_OK)
            fprintf(stderr, "Error scheduling frame\n");
    }
    videoFrame->Release();
    av_free_packet(&pkt);
}
Exemple #5
0
static void *video_thread(ALLEGRO_THREAD * t, void *arg)
{
   VideoState *is = (VideoState *) arg;
   AVPacket pkt1, *packet = &pkt1;
   int len1, frameFinished;
   AVFrame *pFrame;
   double pts;
   (void)t;

   pFrame = avcodec_alloc_frame();

   for (;;) {
      if (packet_queue_get(is, &is->videoq, packet, 1) < 0) {
         // means we quit getting packets
         break;
      }
      if (packet->data == flush_pkt.data) {
         avcodec_flush_buffers(is->video_st->codec);
         continue;
      }
      pts = 0;

      // Save global pts to be stored in pFrame
      FIXME_global_video_pkt_pts = packet->pts;
   
      // Decode video frame
#ifdef FFMPEG_0_8
      len1 = avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,
                                  packet);
#else
      len1 = avcodec_decode_video(is->video_st->codec, pFrame, &frameFinished,
                                  packet->data, packet->size);
#endif
                                  

      if (packet->dts == NOPTS_VALUE
          && pFrame->opaque && *(int64_t *) pFrame->opaque != NOPTS_VALUE) {
         pts = 0;//*(uint64_t *) pFrame->opaque;
      }
      else if (packet->dts != NOPTS_VALUE) {
         pts = packet->dts;
      }
      else {
         pts = 0;
      }
      pts *= av_q2d(is->video_st->time_base);

      // Did we get a video frame?
      if (frameFinished) {
         //pts = synchronize_video(is, pFrame, pts);
         if (queue_picture(is, pFrame, pts) < 0) {
            break;
         }
      }
      av_free_packet(packet);
   }
   av_free(pFrame);
   return NULL;
}
Exemple #6
0
void *video_thread(void *arg) {
  JNIEnv *env;
  if((*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL) != JNI_OK) {
       LOGE(1, "### start video thead error");
	   return;
  }
  VideoState *is = (VideoState*)arg;
  AVPacket pkt1, *packet = &pkt1;
  int len1, frameFinished;
  AVFrame *pFrame;
  double pts;
  int numBytes;
  pFrame=avcodec_alloc_frame();
  int ret;
  for(;;) {
	if(is->quit == 1 || is->quit == 2) {
		break;
	}
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
	  if(debug) LOGI(10,"video_thread get packet exit");
      break;
    }
    pts = 0;
    global_video_pkt_pts = packet->pts;
    len1 = avcodec_decode_video2(is->video_st->codec,
				pFrame,
				&frameFinished,
				packet);	
    if(packet->dts == AV_NOPTS_VALUE
       && pFrame->opaque
       && *(uint64_t*)pFrame->opaque
       != AV_NOPTS_VALUE) {
      pts = *(uint64_t*) pFrame->opaque;
    } else if (packet->dts != AV_NOPTS_VALUE) {
      pts = packet->dts;
    } else {
      pts = 0;
    }
    pts *= av_q2d(is->video_st->time_base);
	//pts *= av_q2d(pCodecCtx->time_base);
    if (frameFinished) {
       pts = synchronize_video(is, pFrame, pts);
       if (queue_picture(is, pFrame, pts) < 0) {
			break;
       }
    }
    av_free_packet(packet);
  }
  av_free(pFrame);
  if((*g_jvm)->DetachCurrentThread(g_jvm) != JNI_OK) {
	LOGE(1,"### detach video thread error");
  }
  pthread_exit(0);
  if(debug) {
		LOGI(1,"### video_thread exit");
  }
  return ((void *)0);
}
Exemple #7
0
int audio_decode_frame(VideoState *is, uint8_t *audio_buf, int buf_size, double *pts_ptr) {

  int len1, data_size, n;
  AVPacket *pkt = &is->audio_pkt;
  double pts;

  for(;;) {
    while(is->audio_pkt_size > 0) {
      data_size = buf_size;
      len1 = avcodec_decode_audio3(is->audio_ctx, 
				  (int16_t *)audio_buf, &data_size, pkt);
				  //is->audio_pkt_data, is->audio_pkt_size);

      //len1 = avcodec_decode_audio2(aCodecCtx, (int16_t *)audio_buf, &data_size, 
			//	  audio_pkt_data, audio_pkt_size);
      if(len1 < 0) {
        // if error, skip frame
        is->audio_pkt_size = 0;
        break;
      }
      is->audio_pkt_data += len1;
      is->audio_pkt_size -= len1;
      if(data_size <= 0) {
        // No data yet, get more frames
        continue;
      }
      pts = is->audio_clock;
      *pts_ptr = pts;
      //n = 2 * is->audio_ctx->channels;
      n = 2;
      is->audio_clock += (double)data_size /
      (double)(n * is->audio_ctx->sample_rate);

      // We have data, return it and come back for more later
      return data_size;
    }
    if(pkt->data)
      av_free_packet(pkt);

    if(is->quit) {
      return -1;
    }

    // next packet
    if(packet_queue_get(&is->audioq, pkt, 1) < 0) {
      return -1;
    }

    is->audio_pkt_data = pkt->data;
    is->audio_pkt_size = pkt->size;

    // if update, update the audio clock w/pts
    if(pkt->pts != AV_NOPTS_VALUE) {
      is->audio_clock = av_q2d(is->audio_ctx->time_base)*pkt->pts;
    }

  }
}
Exemple #8
0
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf,  
					   int buf_size) {  

						   static AVPacket pkt;
						   static uint8_t *audio_pkt_data = NULL;
						   static int audio_pkt_size = 0;

						   int len1, data_size = 0;

						   for(;;) {
							   while(audio_pkt_size > 0) {
								   int got_frame = 0;
								   len1 = avcodec_decode_audio4
									   (aCodecCtx, m_audio_frame, &got_frame, &pkt);

								   if(len1 < 0) 
								   {
									   audio_pkt_size = 0;
									   break;
								   }

								   audio_pkt_data += len1;
								   audio_pkt_size -= len1;
								   data_size = 0;

								   if(got_frame) 
								   {
									   data_size = 
										   av_samples_get_buffer_size(NULL, aCodecCtx->channels,
										   m_audio_frame->nb_samples,
										   aCodecCtx->sample_fmt, 1);
									   //assert(data_size <= buf_size);
									   memcpy(audio_buf, m_audio_frame->data[0], data_size);
								   }

								   if(data_size <= 0)
								   {
									   /* No data yet, get more frames */
									   continue;
								   }
								   /* We have data, return it and come back for more later */
								   return data_size;
							   }

							   if(pkt.data)
								   av_packet_unref(&pkt);

							   if(quit) {
								   return -1;
							   }

							   if(packet_queue_get(&m_audio_q, &pkt, 1) < 0) {
								   return -1;
							   }
							   audio_pkt_data = pkt.data;
							   audio_pkt_size = pkt.size;
						   }
}  
Exemple #9
0
int audio_decode_frame( void )
{
        //printf( "In Audio decode frame : Thread \n" );
        SDL_Event quit_audio_event;

        quit_audio_event.type = QUIT_AUDIO_EVENT;

        PacketQueue *pAQueue = &( gMedia->audioQueue ) ;
        static AVPacket packet;
        AVFrame *pFrame = avcodec_alloc_frame() ;
        int pkt_bytes_decd = 0;
        int audio_data_size = 0;
        int frame_fin = 0;

        if ( packet.size == 0 ) {
                if ( !packet_queue_get( pAQueue, &packet ) ) {
                        SDL_PushEvent( &quit_audio_event );
                        av_free( pFrame );
                        return -1;
                }
        }

        while ( packet.size > 0 ) {
                // printf("Size of packet is %d\n",packet.size);
                pkt_bytes_decd = avcodec_decode_audio4( gMedia->aCodecContext,
                                                        pFrame,
                                                        &frame_fin,
                                                        &packet );

                printf( "%d bytes from packet decoded\n", pkt_bytes_decd );
                // printf("Format of Decoded frame is %d\n",pFrame->format);
                // printf("Format of audio is %d\n",pFrame->nb_samples);

                //               aud_frame_pts = pFrame->pkt_pts ;
                //printf( " audio frame : pts is %" PRId64 "\n", aud_frame_pts );

                if ( pkt_bytes_decd < 0 ) {
                        /* if error, skip packet */
                        break;
                }

                if ( frame_fin ) {
                        audio_data_size = create_channel_data( pFrame );
                        packet.size -= pkt_bytes_decd;
                        av_free( pFrame );
                        return audio_data_size ;
                }
        }

        /*        if ( pkt->pts != AV_NOPTS_VALUE ) {
                        gMedia->audio_clock = av_q2d( gMedia->pFormatContext->
                                                      streams[aud_stream_index] )
                                              * pkt->pts;
                }
        */
        return 1; //Never comes here
}
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size) 
{
	//ffplay_info("Start.\n");

	static AVPacket pkt;
	static uint8_t *audio_pkt_data = NULL;
	static int audio_pkt_size = 0;

	int len1, data_size;

	for(;;) 
	{
		while(audio_pkt_size > 0) 
		{
			data_size = buf_size;

			len1 = avcodec_decode_audio3(aCodecCtx, (int16_t *)audio_buf, &data_size, 
					  &pkt);
			ffplay_info("audio_buf = 0x%8x, data_size = %d, pkt = 0x%8x\n",audio_buf,data_size,&pkt);
			if(len1 < 0) 
			{
				/* if error, skip frame */
				audio_pkt_size = 0;
				break;
			}
			audio_pkt_data += len1;
			audio_pkt_size -= len1;
			if(data_size <= 0) 
			{
				/* No data yet, get more frames */
				continue;
			}
			/* We have data, return it and come back for more later */
			return data_size;
		}
		if(pkt.data)
		{
			ffplay_info("Here.\n");
			av_free_packet(&pkt);
		}
		if(quit) 
		{
			ffplay_info("Here.\n");
			return -1;
		}

		if(packet_queue_get(&audioq, &pkt, 1) < 0) 
		{
			ffplay_info("Here.\n");
			return -1;
		}
		audio_pkt_data = pkt.data;
		audio_pkt_size = pkt.size;
	}
	//ffplay_info("end.\n");
}
int video_thread(void *arg) {
    VideoState *is = (VideoState *)arg;
    AVPacket pkt1, *packet = &pkt1;
    int frameFinished;
    AVFrame *pFrame;
    double pts;

    pFrame = avcodec_alloc_frame();

    for(;;) {
        if(packet_queue_get(&is->videoq, packet, 1) < 0) {
            // means we quit getting packets
            break;
        }

        if(packet->data == flush_pkt.data) {
            avcodec_flush_buffers(is->video_st->codec);
            continue;
        }

        pts = 0;

        // Save global pts to be stored in pFrame in first call
        global_video_pkt_pts = packet->pts;
        // Decode video frame
        avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,
                              packet);

        if(packet->dts == AV_NOPTS_VALUE
                && pFrame->opaque && *(uint64_t*)pFrame->opaque != AV_NOPTS_VALUE) {
            pts = *(uint64_t *)pFrame->opaque;

        } else if(packet->dts != AV_NOPTS_VALUE) {
            pts = packet->dts;

        } else {
            pts = 0;
        }

        pts *= av_q2d(is->video_st->time_base);

        // Did we get a video frame?
        if(frameFinished) {
            pts = synchronize_video(is, pFrame, pts);

            if(queue_picture(is, pFrame, pts) < 0) {
                break;
            }
        }

        av_free_packet(packet);
    }

    av_free(pFrame);
    return 0;
}
Exemple #12
0
int audio_decode_frame(AVCodecContext *aCodecCtx, AVPacket *pkt, AVPacket *pkt_temp, AVFrame *frame, uint8_t *audio_buf)
{
	int len1, data_size;
	int got_frame = 0;
	int new_packet = 0;

	while(1)
	{
		while(pkt_temp->size > 0 || (!pkt_temp->data && new_packet))
		{
			if(!frame)
			{
				if(!(frame = avcodec_alloc_frame()))
					return AVERROR(ENOMEM);
			}
			else
			{
				avcodec_get_frame_defaults(frame);
			}
			new_packet = 0;
			got_frame = 0;
			len1 = avcodec_decode_audio4(aCodecCtx, frame, &got_frame, pkt_temp);
			if(len1 < 0)
			{
				/*if error, skip frame*/
				pkt_temp->size = 0;
				av_free_packet(pkt_temp);
				continue;
			}
			pkt_temp->data += len1;
			pkt_temp->size -= len1;
			if(!got_frame)
			{
				/*stop sending empty packets if the decoder is finished*/
				continue;
				//break;
			}
			data_size = av_samples_get_buffer_size(NULL, aCodecCtx->channels, frame->nb_samples, aCodecCtx->sample_fmt, 1);
			memcpy(audio_buf, frame->data[0], frame->linesize[0]);
			return data_size;
		}
		if(pkt->data)
			av_free_packet(pkt);
		memset(pkt_temp, 0, sizeof(*pkt_temp));
		if(quit)
		{
			return -1;
		}
		if((new_packet = packet_queue_get(&audioq, pkt, 1)) < 0)
		{
			return -1;
		}
		*pkt_temp = *pkt;
	}
}
int video_thread(void *arg) {
  VideoState *is = (VideoState *)arg;
  AVPacket pkt1, *packet = &pkt1;
  int len1, frameFinished;
  AVFrame *pFrame;
  double pts;

  pFrame = avcodec_alloc_frame();

  is->rgbaFrame = avcodec_alloc_frame();
  avpicture_alloc ((AVPicture *)is->rgbaFrame, PIX_FMT_RGBA, is->video_st->codec->width, is->video_st->codec->height);


  for(;;) {
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
      // means we quit getting packets
      break;
    }
    pts = 0;

    // Save global pts to be stored in pFrame
    global_video_pkt_pts = packet->pts;
    // Decode video frame
    len1 = avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,
        packet);
    if(packet->dts == AV_NOPTS_VALUE
       && pFrame->opaque && *(uint64_t*)pFrame->opaque != AV_NOPTS_VALUE) {
      pts = (double)(*(uint64_t *)pFrame->opaque);
    } else if(packet->dts != AV_NOPTS_VALUE) {
		pts = (double)packet->dts;
    } else {
      pts = 0;
    }
    pts *= av_q2d(is->video_st->time_base);


    // Did we get a video frame?
    if(frameFinished) {
      pts = synchronize_video(is, pFrame, pts);
      if(queue_picture(is, pFrame, pts) < 0) {
  break;
      }
    }
    av_free_packet(packet);
  }

  SDL_CloseAudio();

  av_free(pFrame);

  avpicture_free((AVPicture *)is->rgbaFrame);
  av_free(is->rgbaFrame);

  return 0;
}
Exemple #14
0
int decode_audio_frame (PlayerContext *ctx, uint8_t **buf)
{
    static AVPacket pkt, cur_pkt;
    static AVFrame *frame;
    int got_frame, decoded_bytes;

    if (!frame)
    {
        frame = avcodec_alloc_frame ();
        if (!frame)
            return AVERROR (ENOMEM);
    }

    for (;;)
    {
        while (pkt.size > 0)
        {
            avcodec_get_frame_defaults (frame);

            decoded_bytes = avcodec_decode_audio4 (ctx->audio_codec,
                                                   frame, &got_frame,
                                                   &pkt);
            if (decoded_bytes < 0)
            {
                // error, skip the frame
                pkt.size = 0;
                break;
            }

            pkt.data += decoded_bytes;
            pkt.size -= decoded_bytes;

            *buf = frame->data[0];

            return av_samples_get_buffer_size(NULL,
                                              frame->channels,
                                              frame->nb_samples,
                                              frame->format, 1);
        }

        // free the current packet
        if (cur_pkt.data)
            av_free_packet (&cur_pkt);
        memset (&pkt, 0, sizeof (pkt));

        if (quit)
            return -1;

        // read next packet
        if (packet_queue_get (&ctx->audioq, &cur_pkt, 1) < 0)
            return -1;

        pkt = cur_pkt;
    }
}
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size) {

	static AVPacket pkt;
	static uint8_t *audio_pkt_data = NULL;
	static int audio_pkt_size = 0;
	static AVFrame frame;
	int len1, resampled_data_size=0;

	for (;;) {
		while (audio_pkt_size > 0) {
			int got_frame = 0;
			len1 = avcodec_decode_audio4(aCodecCtx, &frame, &got_frame, &pkt);
			if (len1 < 0) {
				/* if error, skip frame */
				audio_pkt_size = 0;
				break;
			}
			audio_pkt_data += len1;
			audio_pkt_size -= len1;

			if (got_frame) {

				// ---------------

				//准备调用 swr_convert 的其他4个必须参数: out,out_samples_per_ch,in,in_samples_per_ch
				uint8_t **out = &audio_buf;
				const uint8_t **in = (const uint8_t **)frame.extended_data;
				//int out_samples_per_ch = buf_size/ (av_get_bytes_per_sample(AV_SAMPLE_FMT_S16)*2);
				//调用 swr_convert 进行转换
				int len2 = 0;
				len2 = swr_convert(swr_ctx, out, frame.nb_samples, in, frame.nb_samples);
				resampled_data_size = len2 * 2 * av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);
				//memcpy(audio_buf, frame.data[0], data_size);

				// ----------------
				
			}
			/* We have data, return it and come back for more later */
			return resampled_data_size;
		}
		if (pkt.data)
			av_free_packet(&pkt);

		if (quit) {
			return -1;
		}

		if (packet_queue_get(&audioq, &pkt, 1) < 0) {
			return -1;
		}
		audio_pkt_data = pkt.data;
		audio_pkt_size = pkt.size;
	}
	
}
Exemple #16
0
int video_thread(void *arg) {
  VideoState *is = (VideoState *)arg;
  AVPacket pkt1, *packet = &pkt1;
  int frameFinished;
  AVFrame *pFrame;
  double pts;

  pFrame = av_frame_alloc();

  for(;;) {
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
      // means we quit getting packets
      break;
    }
    if(packet_queue_get(&is->videoq, packet, 1) < 0) {
      // means we quit getting packets
      break;
    }
    pts = 0;

    // Decode video frame
    avcodec_decode_video2(is->video_ctx, pFrame, &frameFinished, packet);

    if((pts = av_frame_get_best_effort_timestamp(pFrame)) == AV_NOPTS_VALUE) {
      pts = av_frame_get_best_effort_timestamp(pFrame);
    } else {
      pts = 0;
    }
    pts *= av_q2d(is->video_st->time_base);

    // Did we get a video frame?
    if(frameFinished) {
      pts = synchronize_video(is, pFrame, pts);
      if(queue_picture(is, pFrame, pts) < 0) {
	break;
      }
    }
    av_free_packet(packet);
  }
  av_frame_free(&pFrame);
  return 0;
}
Exemple #17
0
int video_decode_audio_frame( AVCodecContext *context, uint8_t *buffer, int buffer_size ) {
    static AVPacket packet;
    int used, data_size;

    for(;;) {
        while( audio_packet_size > 0 ) {
            data_size = buffer_size;

            AVPacket avp;
            av_init_packet( &avp );
            avp.data = audio_packet_data;
            avp.size = audio_packet_size;

            used = avcodec_decode_audio3( context, (int16_t *)audio_buffer, &data_size,
                                          &avp );
            if( used < 0 ) {
                /* if error, skip frame */
                audio_packet_size = 0;
                break;
            }
            audio_packet_data += used;
            audio_packet_size -= used;

            if( data_size <= 0 ) {
                /* No data yet, get more frames */
                continue;
            }

            audio_clock += (double)data_size /
                           (double)(format_context->streams[audio_stream]->codec->sample_rate *
                                    (2 * format_context->streams[audio_stream]->codec->channels));

            /* We have data, return it and come back for more later */
            return data_size;
        }
        if( packet.data )
            av_free_packet( &packet );

        if( stop ) {
            audio_running = 0;
            return -1;
        }

        if( packet_queue_get( &audio_queue, &packet, 1 ) < 0 )
            return -1;

        audio_packet_data = packet.data;
        audio_packet_size = packet.size;

        if( packet.pts != AV_NOPTS_VALUE ) {
            audio_clock = packet.pts * av_q2d( format_context->streams[audio_stream]->time_base );
        }
    }
}
Exemple #18
0
int video_thread(void *arg) {
	VideoState *is = (VideoState*)arg;
	AVPacket pkt1, *packet = &pkt1;
	int len1, frameFinished;
	AVFrame *pFrame;
	double pts;

	pFrame = avcodec_alloc_frame();

	for(;;) {
		//printf("video_thread loop 1\n");
		if(packet_queue_get(&is->videoq, packet, 1) < 0) {
			fprintf(stderr, "%d: packet_queue_get errror\n", __LINE__);
			break;
		}
		//printf("video_thread loop 2\n");
		if(packet->data == flush_pkt.data) {
			avcodec_flush_buffers(is->video_st->codec);
			continue;
		}
		//printf("video_thread loop 3\n");
		pts = 0;
		global_video_pkt_pts = packet->pts;
		//printf("video_thread loop 4\n");
		len1 = avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished, packet);
/*
		if(packet->dts == AV_NOPTS_VALUE && *(uint64_t*)pFrame->opaque != AV_NOPTS_VALUE) {
			pts = *(uint64_t*)pFrame->opaque;
		} else if(packet->dts != AV_NOPTS_VALUE) {
			pts = packet->dts;
		} else {
			pts = 0;
		}

		pts *= av_q2d(is->video_st->time_base);
*/
		//printf("video_thread loop 5\n");
		if(frameFinished) {
			//printf("video_thread loop 6\n");
			pts = synchronize_video(is, pFrame, pts);
			//printf("video_thread loop 7\n");
			if(queue_picture(is, pFrame, pts) < 0) 
			{
				//printf("video_thread loop 8\n");
				break;
			}
		}
		//printf("video_thread loop 6\n");
		av_free_packet(packet); 
	}
	av_free(pFrame);
	//printf("video_thread loop end\n");
	return 0;
}
int audio_decode_frame(VideoState *is, uint8_t *audio_buf, int buf_size,double *pts_ptr)
{
    AVCodecContext *aCodecCtx = is->audio_st->codec;
    static AVPacket pkt;
    static uint8_t *audio_pkt_data = NULL;
    static int audio_pkt_size = 0;
    static AVFrame frame;

    int len1, data_size = 0;
    double pts;

    for(;;) {
        while(audio_pkt_size > 0) {
            int got_frame = 0;
            len1 = avcodec_decode_audio4(aCodecCtx, &frame, &got_frame, &pkt);
            if(len1 < 0) {
                /* if error, skip frame */
                audio_pkt_size = 0;
                break;
            }
            data_size = AudioResampling(aCodecCtx,&frame, AV_SAMPLE_FMT_S16,aCodecCtx->channels, 44100, audio_buf);
            audio_pkt_data += len1;
            audio_pkt_size -= len1;

            if(data_size <= 0) {
                continue;
            }
            pts = is->audio_clock;
            *pts_ptr = pts;
            int n = 2 * is->audio_st->codec->channels;
            is->audio_clock += (double)data_size /
                (double)(n * is->audio_st->codec->sample_rate);
            /* We have data, return it and come back for more later */
            return data_size;
        }
        if(pkt.data)
            av_free_packet(&pkt);

        if(is->quit) {
            return -1;
        }

        if(packet_queue_get(&is->audioq, &pkt, 1) < 0) {
            return -1;
        }
        audio_pkt_data = pkt.data;
        audio_pkt_size = pkt.size;

        if(pkt.pts != AV_NOPTS_VALUE){
            is->audio_clock = av_q2d(is->audio_st->time_base)*pkt.pts;
        }
    }
}
Exemple #20
0
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size) 
{
	static AVPacket pkt;
	static uint8_t *audio_pkt_data = NULL;
	static int audio_pkt_size = 0;
	AVFrame *pFrame = av_frame_alloc();
    int got_frame;
	
	int len1, data_size;

	for(;;) {
		while(audio_pkt_size > 0) {
			data_size = buf_size;
			#if 0
			len1 = avcodec_decode_audio4(aCodecCtx, pFrame, &got_frame, &pkt);
			#else
			len1 = avcodec_decode_audio3(aCodecCtx, (int16_t *)audio_buf, &data_size, &pkt);
			#endif
			if(len1 < 0) {
				/* if error, skip frame */
				audio_pkt_size = 0;
				break;
			}
			audio_pkt_data += len1;
			audio_pkt_size -= len1;
			if(data_size <= 0) {
				/* No data yet, get more frames */
				continue;
			}
			/* We have data, return it and come back for more later */
			av_frame_free(&pFrame);
			return data_size;
		}
		if(pkt.data)
			av_free_packet(&pkt);

		if(quit) {
			av_frame_free(&pFrame);
			return -1;
		}

		if(packet_queue_get(&audioq, &pkt, 1) < 0) {
			av_frame_free(&pFrame);
			return -1;
		}
		audio_pkt_data = pkt.data;
    		audio_pkt_size = pkt.size;
		printf("\r\n audio_pkt_size:%d!!\r\n",audio_pkt_size);
	}
}
Exemple #21
0
int video_thread(void* arg) {
	VideoState* is = (VideoState*) arg;
	AVPacket pkt1, *packet = &pkt1;
	int frameFinished;
	AVFrame* pFrame, *pFrameYUV;
	uint8_t *out_buffer;
	double pts;

	pFrame = av_frame_alloc();
	pFrameYUV = av_frame_alloc();

	out_buffer = (uint8_t*) av_malloc(
			avpicture_get_size(AV_PIX_FMT_YUV420P, is->video_ctx->width,
					is->video_ctx->height));
	avpicture_fill((AVPicture*) pFrameYUV, out_buffer, AV_PIX_FMT_YUV420P,
			is->video_ctx->width, is->video_ctx->height);

	for (;;) {
		if (packet_queue_get(&is->videoq, packet, 1, 1) < 0) {
			break;
		}

		if (packet->data == flush_pkt.data) {
			avcodec_flush_buffers(is->video_ctx);
			continue;
		}

		pts = 0;
		avcodec_decode_video2(is->video_ctx, pFrame, &frameFinished, packet);

		if ((pts = av_frame_get_best_effort_timestamp(pFrame)) == AV_NOPTS_VALUE) {
			pts = 0;
		}
		pts *= av_q2d(is->video_st->time_base);

		printf("queue_picture frameFinished=%d  packet->size=%d  pts=%lf\n",
				frameFinished, packet->size, pts);
		if (frameFinished) {
			pts = synchronize_video(is, pFrame, pts);
			if (queue_picture(is, pFrame, pFrameYUV, pts) < 0) {
				break;
			}
		}
		av_free_packet(packet);
	}

	av_frame_free(&pFrame);
	av_frame_free(&pFrameYUV);
	return 0;
}
Exemple #22
0
/* decode one audio frame and returns its uncompressed size */
static int audio_decode_frame(FFMovie *movie, uint8_t *audio_buf, double *pts_ptr)
{
/*SDL AUDIO THREAD*/
    AVPacket *pkt = &movie->audio_pkt;
    int len1, data_size;
    double pts;

    for(;;) {
        if (movie->paused || movie->audioq.abort_request || Global_abort_all) {
            return -1;
        }
        while (movie->audio_pkt_size > 0) {
            len1 = avcodec_decode_audio(&movie->audio_st->codec,
                                        (int16_t *)audio_buf, &data_size,
                                        movie->audio_pkt_data, movie->audio_pkt_size);
            if (len1 < 0)
                break;
            movie->audio_pkt_data += len1;
            movie->audio_pkt_size -= len1;
            if (data_size > 0) {
                pts = 0;
                if (movie->audio_pkt_ipts != AV_NOPTS_VALUE)
                    pts = (double)movie->audio_pkt_ipts * movie->context->pts_num / movie->context->pts_den;
                /* if no pts, then compute it */
                if (pts != 0) {
                    movie->audio_clock = pts;
                } else {
                    int n;
                    n = 2 * movie->audio_st->codec.channels;
                    movie->audio_clock += (double)data_size / (double)(n * movie->audio_st->codec.sample_rate);
                }
                *pts_ptr = movie->audio_clock;
                movie->audio_pkt_ipts = AV_NOPTS_VALUE;
                /* we got samples : we can exit now */
                return data_size;
            }
        }

        /* free previous packet if any */
        if (pkt->destruct)
            av_free_packet(pkt);

        /* read next packet */
        if (packet_queue_get(&movie->audioq, pkt, 1) < 0)
            return -1;
        movie->audio_pkt_data = pkt->data;
        movie->audio_pkt_size = pkt->size;
        movie->audio_pkt_ipts = pkt->pts;
    }
}
int audio_decode_frame(VideoState *is) {

        int len1, data_size = 0;
        AVPacket *pkt = &is->audio_pkt;

        for (;;) {
                while (is->audio_pkt_size > 0) {
                        int got_frame = 0;
                        len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,
                                        &got_frame, pkt);
                        if (len1 < 0) {
                                /* if error, skip frame */
                                is->audio_pkt_size = 0;
                                break;
                        }

                        if (got_frame) {
                                data_size = is->audio_frame.linesize[0];
                                /*av_samples_get_buffer_size(NULL,
                                 is->audio_st->codec->channels,
                                 is->audio_frame.nb_samples,
                                 is->audio_st->codec->sample_fmt, 1);*/
                                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);
                        }

                        is->audio_pkt_data += len1;
                        is->audio_pkt_size -= len1;
                        if (data_size <= 0) {
                                /* No data yet, get more frames */
                                continue;
                        }
                        /* We have data, return it and come back for more later */
                        return data_size;
                }
                if (pkt->data)
                        av_free_packet(pkt);

                if (is->quit) {
                        return -1;
                }
                /* next packet */
                if (packet_queue_get(&is->audioq, pkt, 1) < 0) {
                        return -1;
                }
                is->audio_pkt_data = pkt->data;
                is->audio_pkt_size = pkt->size;
        }

        return 0;
}
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf,
                       int buf_size) {
    static AVPacket pkt;
    static uint8_t *audio_pkt_data = NULL;
    static int audio_pkt_size = 0;
    static AVFrame frame;

    int len1, data_size;

    for (;;) {
        while (audio_pkt_size > 0) {
            int got_frame = 0;
            len1 = avcodec_decode_audio4(aCodecCtx, &frame, &got_frame, &pkt);
            if (len1 < 0) {
                // if error, skip frame
                audio_pkt_size = 0;
                break;
            }
            audio_pkt_data += len1;
            audio_pkt_size -= len1;
            if (got_frame) {
                data_size = av_samples_get_buffer_size(NULL,
                                                       aCodecCtx->channels,
                                                       frame.nb_samples,
                                                       aCodecCtx->sample_fmt,
                                                       1);
                memcpy(audio_buf, frame.data[0], data_size);
            }
            if (data_size <= 0) {
                // No data yet, get more frames
                continue;
            }
            // We have data, return it and come back for more later
            return data_size;
        }
        if (pkt.data) {
            av_free_packet(&pkt);
        }
        if (quit) {
            return -1;
        }
        if (packet_queue_get(&audioq, &pkt, 1) < 0) {
            return -1;
        }
        audio_pkt_data = pkt.data;
        audio_pkt_size = pkt.size;
    }
}
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size) {

  static AVPacket pkt;
  static uint8_t *audio_pkt_data = NULL;
  static int audio_pkt_size = 0;

  int len1, data_size;

  for(;;) {
    while(audio_pkt_size > 0) {
      data_size = buf_size;
      /*
len1 = avcodec_decode_audio3(aCodecCtx, (int16_t *)audio_buf, &data_size, 
				  audio_pkt_data, audio_pkt_size);
*/
      len1 = avcodec_decode_audio3(aCodecCtx, (int16_t *)audio_buf, &data_size, 
				  &pkt);
      audio_pkt_data = pkt.data;
      audio_pkt_size = pkt.size;

      if(len1 < 0) {
	/* if error, skip frame */
	audio_pkt_size = 0;
	break;
      }
      audio_pkt_data += len1;
      audio_pkt_size -= len1;
      if(data_size <= 0) {
	/* No data yet, get more frames */
	continue;
      }
      /* We have data, return it and come back for more later */
      return data_size;
    }
    if(pkt.data)
      av_free_packet(&pkt);

    if(quit) {
      return -1;
    }

    if(packet_queue_get(&audioq, &pkt, 1) < 0) {
      return -1;
    }
    audio_pkt_data = pkt.data;
    audio_pkt_size = pkt.size;
  }
}
Exemple #26
0
void *video_thread(void *arg)
{
    //fprintf(stdout, "[FFmpeg-decode thread] video_thread created\n");
    VideoState *is = (VideoState *)arg;
    AVPacket pkt1, *packet = &pkt1;
    int frameFinished=0;
    int index=0;

    //pthread_create(&is->trans_tid, NULL, transcode_thread, (void *)is);
    
    //fprintf(stdout, "[FFmpeg-video thread] decode frame\n");
    index=get_frame_status(is,FRAME_WAIT_WRITE);
    for(;;)
    {
        if(is->quit)
        {
            break;
        }
        if(packet_queue_get(&is->videoq, packet, 1) < 0)
        {
            // means we quit getting packets
            break;
        }
        // Decode video frame
        
        avcodec_decode_video2(is->video_st->codec, is->frames[0], &frameFinished, packet);
        //fprintf(stdout,"Current packs in queue:%d\n",is->videoq.nb_packets);
        if(frameFinished)
        {
            init_picture(is, 0);

//            if(index!=FRAME_SIZE)
//            {
//                pthread_mutex_lock(&is->mutex);
//                pthread_cond_signal(&is->cond);
//                set_frame_status(is, FRAME_WAIT_TRANSCODE);
//                pthread_mutex_unlock(&is->mutex);
//            }
//            index=get_frame_status(is,FRAME_WAIT_WRITE);
        }
        av_free_packet(packet);
    }
    
    fprintf(stdout, "[FFmpeg-video thread] thread terminated\n");
    return NULL;
}
Exemple #27
0
int audio_decode_frame(VideoState*is, int16_t *audio_buf, int buf_size, double *pts_ptr) {
  int len1, data_size, n;
  AVPacket *pkt = &is->audio_pkt;
  double pts;  
  int index = 0;
  for (;;) {
    while (is->audio_pkt_size > 0) {
      data_size = AVCODEC_MAX_AUDIO_FRAME_SIZE*3/2;
      len1 = avcodec_decode_audio3(is->audio_st->codec,
                                   audio_buf, 
                                  &data_size,
                                   pkt);
      if (len1 < 0) {
		is->audio_pkt_size = 0;
		break;
      }
      is->audio_pkt_data += len1;
      is->audio_pkt_size -= len1;
      if (data_size < 0) {
		continue;
      }
	  index +=data_size;
      pts = is->audio_clock;
      *pts_ptr = pts;
      n = 2 * is->audio_st->codec->channels;
      is->audio_clock += (double)data_size / (double)(n*is->audio_st->codec->sample_rate);
      return data_size;
    }
    if (pkt->data) {
      av_free_packet(pkt);
    }
    if (is->quit) {
      return -1;
    }
    if (packet_queue_get(&is->audioq, pkt, 1) < 0) {
      return -1;
    }
    is->audio_pkt_data = pkt->data;
    is->audio_pkt_size = pkt->size;
    if (pkt->pts != AV_NOPTS_VALUE) {
		is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
	}
  }
}
Exemple #28
0
int video_thread(void *arg) {
  VideoState *is = (VideoState *)arg;
  AVPacket pkt1, *packet = &pkt1;
  int len1, frameFinished;
  AVFrame *pFrame;
  double pts;

  pFrame = avcodec_alloc_frame();

  for(;;) {
    // if we stopped getting packets
    while( packet_queue_get(&is->videoq, packet, 1) == 0 ) {
    }

    pts = 0;
    // Save global pts to be stored in pFrame in first call
    global_video_pkt_pts = packet->pts;

    // Decode video frame
    //frameCount++;
    len1 = avcodec_decode_video2(is->video_ctx, pFrame, &frameFinished, packet );

    if(packet->dts != AV_NOPTS_VALUE) {
      pts = packet->dts;
    } else {
      pts = 0;
    }
    pts *= av_q2d(is->video_ctx->time_base);


    // Frame is decoded, queue it to be played
    if(frameFinished) {
      pts = synchronize_video( is, pFrame, pts);
      if(queue_picture(is, pFrame, pts) < 0) {
        break;
      }
    }

    // Cleanup...
    av_free_packet(packet);
  }
  av_free(pFrame);
  return 0;
}
Exemple #29
0
int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size) {

    static AVPacket pkt;
    static uint8_t *audio_pkt_data = NULL;
    static int audio_pkt_size = 0;
	// len1: number of bytes used to decompress
	// data_size: out put buffer size
    int len1, data_size;

    for(;;) {
        while(audio_pkt_size > 0) {
            data_size = buf_size;
            // @see http://dranger.com/ffmpeg/functions.html#avcodec_decode_audio2
            len1 = avcodec_decode_audio2(aCodecCtx, (int16_t *)audio_buf, &data_size,
                                         audio_pkt_data, audio_pkt_size);
            if(len1 < 0) {
                /* if error, skip frame */
                audio_pkt_size = 0;
                break;
            }
            audio_pkt_data += len1;
            audio_pkt_size -= len1;
            if(data_size <= 0) {
                /* No data yet, get more frames */
                continue;
            }
            /* We have data, return it and come back for more later */
            return data_size;
        }
        if(pkt.data)
            av_free_packet(&pkt);

        if(quit) {
            return -1;
        }

        if(packet_queue_get(&audioq, &pkt, 1) < 0) {
            return -1;
        }
        audio_pkt_data = pkt.data;
        audio_pkt_size = pkt.size;
    }
}
int video_thread(void *arg)
{
    VideoState *is = (VideoState *)arg;
    AVPacket pkt1, *packet = &pkt1;
    int frameFinished;
    AVFrame *pFrame;

    pFrame = av_frame_alloc();
    double pts;
    for(;;) {
        if(packet_queue_get(&is->videoq, packet, 1) < 0) {
            // means we quit getting packets
            break;
        }
        pts = 0;
        global_video_pkt_pts = packet->pts;
        // Decode video frame
        avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,
                packet);
        /* if(packet->dts == AV_NOPTS_VALUE */
        /*         && pFrame->opaque && *(uint64_t*)pFrame->opaque != (uint64_t)AV_NOPTS_VALUE) { */
        /*     pts = *(uint64_t *)pFrame->opaque; */
        /* } else if(packet->dts != AV_NOPTS_VALUE) { */
        /*     pts = packet->dts; */
        /* } else { */
        /*     pts = 0; */
        /* } */
        if(packet->dts !=AV_NOPTS_VALUE)
            pts = packet->dts;
        //转化pts以秒显示
        pts *= av_q2d(is->video_st->time_base);
        // Did we get a video frame?
        if(frameFinished) {
            synchronize_video(is,pFrame,pts);
            if(queue_picture(is, pFrame,pts) < 0) {
                break;
            }
        }
        av_free_packet(packet);
    }
    av_free(pFrame);
    return 0;
}