Recherche avancée

Sur d’autres sites (10056)

• Use FFmpeg to rotate the video based on its metadata ? Why does Android put the wrong metadata ?

  22 juillet 2015, par Mauro Valvano

  I have a website where the user uploads a video.
  For my website i have also an Android application.
  The website creates a thumbnail of each uploaded video (from browser or Android).

  The problem is that for normal videos it’s all OK, but for android my videos are rotated by 90°.

  I think that Android has a bug, because when I see with FFmpeg the video’s metadata, for a normal recorded video I got a rotate=90 value, and for a 90° rotated video, I don’t have anything in the metadata (and the thumbnail is correct).

  Why ?

  This is an image of a normal recorded video (with the phone in portrait mode).

  

  Anyway, I have the metadata in the video, can I create its thumbnail based on its metadata’s rotate value without extracting the metadata and then use ffmpeg to rotate the video on this value ?

  Thank you in advance.

• Convert mp4 videos to support streaming in android

  30 août 2015, par Ibrahim El_Khatib

  I am developing android application that record a video in mp4 format and upload it to a server, then other users can view that video.

  My problem is that the mp4 is not supporting streaming which I need in my app, instead it needs to download all the video to start playing it.

  I googled the issue and I found that mp4 that supports streaming have the faststart property which is putting the moov atom in the beginning of the video file.

  My question is how to achieve that in android if it can be ?? if not can I do it in the server and how ?

  My code to record video is :

  if (requestCode == REQUEST_VIDEO_CAPTURE ) {
  
  
  
  
  
          try
  
          {
  
              Log.e("videopath","videopath");
  
          AssetFileDescriptor videoAsset = getContentResolver().openAssetFileDescriptor(data.getData(), "r");
  
          FileInputStream fis = videoAsset.createInputStream();
  
  
  
          File root = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES);
  
          if (!root.exists()) {
  
                root.mkdirs();
  
          }
  
          File file;
  
          file=new File(root,"android_"+System.currentTimeMillis()+".mp4" );
  
          videoUri = Uri.fromFile(file);
  
          FileOutputStream fos = new FileOutputStream(file);
  
  
  
          byte[] buf = new byte[1024];
  
          int len;
  
          while ((len = fis.read(buf)) > 0) {
  
              fos.write(buf, 0, len);
  
          }       
  
          fis.close();
  
          fos.close();
  
        } 
  
          catch (Exception e) 
  
          {
  
              e.printStackTrace();
  
          }
  
  
  
          return;
  
      }

• Is it possible to establish youtube live stream with ffmgep from Android if video encoded on another device

  20 mai 2015, par Nick Kleban

  I have "Android Device" and some other "Device with camera". This device captures video, encodes it (h264) and sends it to my phone through UDP. On phone i’m receiving only AVFrame’s and it enough to decode and show this video on phone screen. But i can’t establish working video stream to youtube.

  The problem is that all examples does encoding and streaming on one device, so they have properly initialized AVStream and AVPaket. I have feeling that i’m missing something but i cant find what. I’ve passed all stages of creating broadcast, stream, initialization of AVFormatContext, and av_interleaved_write_frame returns 0. Seems like all ok.
  But on youtube i see short living indication of video stream quality, then it dissapears, and all the time there is no video.

  So the question is is it possible to establish video stream to Youtube live if you have only AVFrames that encoded on some other device, and you missing some context information ? If so - what i’m missing ?

  static AVFormatContext *fmt_context = NULL;
  
  static AVStream *video_stream;
  
  
  
  eLIVESTREAM_ERROR LIVESTREAM_Manager_Start(char* url) {
  
      eLIVESTREAM_ERROR error = LIVESTREAM_ERROR;
  
      av_register_all();
  
      avcodec_register_all();
  
      fmt_context = avformat_alloc_context();
  
  
  
      AVOutputFormat *ofmt = NULL;
  
      if (fmt_context != NULL) {
  
          ofmt = av_guess_format("flv", NULL, NULL);
  
          if (ofmt != NULL) {
  
              fmt_context->oformat = ofmt;
  
  
  
              video_stream = av_new_stream(fmt_context, 0);
  
              AVCodec *video_codec = avcodec_find_decoder(AV_CODEC_ID_H264);
  
              AVCodecContext *video_codec_ctx = video_stream->codec;
  
              video_codec_ctx->pix_fmt = PIX_FMT_YUV420P;
  
              video_codec_ctx->skip_frame = AVDISCARD_DEFAULT;
  
              video_codec_ctx->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
  
              video_codec_ctx->skip_loop_filter = AVDISCARD_DEFAULT;
  
              video_codec_ctx->workaround_bugs = FF_BUG_AUTODETECT;
  
              video_codec_ctx->codec_type = AVMEDIA_TYPE_VIDEO;
  
              video_codec_ctx->codec_id = AV_CODEC_ID_H264;
  
              video_codec_ctx->skip_idct = AVDISCARD_DEFAULT;
  
              video_codec_ctx->time_base.num = 1;
  
              video_codec_ctx->time_base.den = 30;
  
              video_codec_ctx->width = 640;
  
              video_codec_ctx->height = 386;
  
  
  
              if(fmt_context->oformat->flags & AVFMT_GLOBALHEADER)  
  
                 video_codec_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  
  
              int codec_open_rslt = avcodec_open2(video_codec_ctx, video_codec, NULL);
  
              if (codec_open_rslt < 0) {
  
                  error = LIVESTREAM_ERROR;
  
              }
  
  
  
              if (!(ofmt->flags & AVFMT_NOFILE)) {
  
                  int open_rslt = avio_open(&fmt_context->pb, url, URL_WRONLY);
  
                  if (open_rslt == 0) {
  
                      int wrt_header_rslt = avformat_write_header(fmt_context, NULL);
  
                      if (wrt_header_rslt == 0) {
  
                          error = LIVESTREAM_OK;
  
                      } else {
  
                          avio_close(fmt_context->pb);
  
                      }
  
                  }
  
              }
  
          }
  
      }
  
      if (error != LIVESTREAM_OK) {
  
          if (ofmt != NULL) {
  
              av_free(ofmt);
  
          }
  
          if (fmt_context != NULL) {
  
              av_free(fmt_context);
  
          }
  
      }
  
      return error;
  
  }
  
  
  
  eLIVESTREAM_ERROR LIVESTREAM_Manager_Send (uint8_t *data , int size) {
  
      eLIVESTREAM_ERROR error = LIVESTREAM_OK;
  
      if (fmt_context == NULL || size <= 0 || data == NULL) {
  
          error = LIVESTREAM_ERROR;
  
      }
  
      if (error == LIVESTREAM_OK) {
  
          AVPacket pkt;
  
          av_init_packet(&pkt);
  
          pkt.stream_index = video_stream->index;
  
          pkt.data = data;
  
          pkt.size = size;
  
          pkt.pts = AV_NOPTS_VALUE;
  
          pkt.dts = AV_NOPTS_VALUE;
  
          pkt.duration = 0;
  
          pkt.pos = -1;
  
          int write_rslt = av_interleaved_write_frame(fmt_context, &pkt);
  
          if (write_rslt != 0) {
  
              error = LIVESTREAM_ERROR;
  
          }
  
      }
  
      return error;
  
  }
  
  
  
  void LIVESTREAM_Manager_Finish () {
  
      av_write_trailer(fmt_context);
  
      avio_close(fmt_context->pb);
  
      av_free(fmt_context);
  
      fmt_context = NULL;
  
  }