Newest 'ffmpeg' Questions - Stack Overflow

Les articles publiés sur le site

• How to fix a segmentaion fault in a C program ? [closed]

  13 janvier 2012, par ipegasus

  Possible Duplicate:
  Segmentation fault

  Currently I am upgrading an open source program used for HTTP streaming. It needs to support the latest FFMPEG. The code compiles fine with no warnings although I am getting a segmentation fault error. I would like to know how to fix the issue? and / or the best way to debug? Please find attached a portion of the code due to size. I will try to add the project to github :) Thanks in advance!

  Sample Usage

  # segmenter --i out.ts --l 10 --o stream.m3u8 --d segments --f stream
  

  Makefile

  FFLIBS=`pkg-config --libs libavformat libavcodec libavutil`
  FFFLAGS=`pkg-config --cflags libavformat libavcodec libavutil`
  
  all:
      gcc -Wall -g segmenter.c -o segmenter ${FFFLAGS} ${FFLIBS}
  

  segmenter.c

  /*
   * Copyright (c) 2009 Chase Douglas
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License version 2
   * as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   */
  #include 
  #include 
  #include 
  #include 
  #include 
  #include "libavformat/avformat.h"
  
  #include "libavformat/avio.h"
  
  #include stat.h>
  
  #include "segmenter.h"
  #include "libavformat/avformat.h"
  
  #define IMAGE_ID3_SIZE 9171
  
  void printUsage() {
      fprintf(stderr, "\nExample: segmenter --i infile --d baseDir --f baseFileName --o playListFile.m3u8 --l 10 \n");
      fprintf(stderr, "\nOptions: \n");
      fprintf(stderr, "--i .\n");
      fprintf(stderr, "--o .\n");
      fprintf(stderr, "--d basedir, the base directory for files.\n");
      fprintf(stderr, "--f baseFileName, output files will be baseFileName-#.\n");
      fprintf(stderr, "--l segment length, the length of each segment.\n");
      fprintf(stderr, "--a,  audio only decode for < 64k streams.\n");
      fprintf(stderr, "--v,  video only decode for < 64k streams.\n");
      fprintf(stderr, "--version, print version details and exit.\n");
      fprintf(stderr, "\n\n");
  }
  
  void ffmpeg_version() {
      // output build and version numbers
      fprintf(stderr, "  libavutil version:   %s\n", AV_STRINGIFY(LIBAVUTIL_VERSION));
      fprintf(stderr, "  libavutil build:     %d\n", LIBAVUTIL_BUILD);
      fprintf(stderr, "  libavcodec version:  %s\n", AV_STRINGIFY(LIBAVCODEC_VERSION));
      fprintf(stdout, "  libavcodec build:    %d\n", LIBAVCODEC_BUILD);
      fprintf(stderr, "  libavformat version: %s\n", AV_STRINGIFY(LIBAVFORMAT_VERSION));
      fprintf(stderr, "  libavformat build:   %d\n", LIBAVFORMAT_BUILD);
      fprintf(stderr, "  built on " __DATE__ " " __TIME__);
  #ifdef __GNUC__
      fprintf(stderr, ", gcc: " __VERSION__ "\n");
  #else
      fprintf(stderr, ", using a non-gcc compiler\n");
  #endif
  }
  
  
  static AVStream *add_output_stream(AVFormatContext *output_format_context, AVStream *input_stream) {
      AVCodecContext *input_codec_context;
      AVCodecContext *output_codec_context;
      AVStream *output_stream;
  
      output_stream = avformat_new_stream(output_format_context, 0);
      if (!output_stream) {
          fprintf(stderr, "Segmenter error: Could not allocate stream\n");
          exit(1);
      }
  
      input_codec_context = input_stream->codec;
      output_codec_context = output_stream->codec;
  
      output_codec_context->codec_id = input_codec_context->codec_id;
      output_codec_context->codec_type = input_codec_context->codec_type;
      output_codec_context->codec_tag = input_codec_context->codec_tag;
      output_codec_context->bit_rate = input_codec_context->bit_rate;
      output_codec_context->extradata = input_codec_context->extradata;
      output_codec_context->extradata_size = input_codec_context->extradata_size;
  
      if (av_q2d(input_codec_context->time_base) * input_codec_context->ticks_per_frame > av_q2d(input_stream->time_base) && av_q2d(input_stream->time_base) < 1.0 / 1000) {
          output_codec_context->time_base = input_codec_context->time_base;
          output_codec_context->time_base.num *= input_codec_context->ticks_per_frame;
      } else {
          output_codec_context->time_base = input_stream->time_base;
      }
  
      switch (input_codec_context->codec_type) {
  #ifdef USE_OLD_FFMPEG
          case CODEC_TYPE_AUDIO:
  #else
          case AVMEDIA_TYPE_AUDIO:
  #endif
              output_codec_context->channel_layout = input_codec_context->channel_layout;
              output_codec_context->sample_rate = input_codec_context->sample_rate;
              output_codec_context->channels = input_codec_context->channels;
              output_codec_context->frame_size = input_codec_context->frame_size;
              if ((input_codec_context->block_align == 1 && input_codec_context->codec_id == CODEC_ID_MP3) || input_codec_context->codec_id == CODEC_ID_AC3) {
                  output_codec_context->block_align = 0;
              } else {
                  output_codec_context->block_align = input_codec_context->block_align;
              }
              break;
  #ifdef USE_OLD_FFMPEG
          case CODEC_TYPE_VIDEO:
  #else
          case AVMEDIA_TYPE_VIDEO:
  #endif
              output_codec_context->pix_fmt = input_codec_context->pix_fmt;
              output_codec_context->width = input_codec_context->width;
              output_codec_context->height = input_codec_context->height;
              output_codec_context->has_b_frames = input_codec_context->has_b_frames;
  
              if (output_format_context->oformat->flags & AVFMT_GLOBALHEADER) {
                  output_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
              }
              break;
          default:
              break;
      }
  
      return output_stream;
  }
  
  int write_index_file(const char index[], const char tmp_index[], const unsigned int planned_segment_duration, const unsigned int actual_segment_duration[],
          const char output_directory[], const char output_prefix[], const char output_file_extension[],
          const unsigned int first_segment, const unsigned int last_segment) {
      FILE *index_fp;
      char *write_buf;
      unsigned int i;
  
      index_fp = fopen(tmp_index, "w");
      if (!index_fp) {
          fprintf(stderr, "Could not open temporary m3u8 index file (%s), no index file will be created\n", tmp_index);
          return -1;
      }
  
      write_buf = malloc(sizeof (char) * 1024);
      if (!write_buf) {
          fprintf(stderr, "Could not allocate write buffer for index file, index file will be invalid\n");
          fclose(index_fp);
          return -1;
      }
  
      unsigned int maxDuration = planned_segment_duration;
  
      for (i = first_segment; i <= last_segment; i++)
          if (actual_segment_duration[i] > maxDuration)
              maxDuration = actual_segment_duration[i];
  
  
  
      snprintf(write_buf, 1024, "#EXTM3U\n#EXT-X-TARGETDURATION:%u\n", maxDuration);
  
      if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
          fprintf(stderr, "Could not write to m3u8 index file, will not continue writing to index file\n");
          free(write_buf);
          fclose(index_fp);
          return -1;
      }
  
      for (i = first_segment; i <= last_segment; i++) {
          snprintf(write_buf, 1024, "#EXTINF:%u,\n%s-%u%s\n", actual_segment_duration[i], output_prefix, i, output_file_extension);
          if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
              fprintf(stderr, "Could not write to m3u8 index file, will not continue writing to index file\n");
              free(write_buf);
              fclose(index_fp);
              return -1;
          }
      }
  
      snprintf(write_buf, 1024, "#EXT-X-ENDLIST\n");
      if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
          fprintf(stderr, "Could not write last file and endlist tag to m3u8 index file\n");
          free(write_buf);
          fclose(index_fp);
          return -1;
      }
  
      free(write_buf);
      fclose(index_fp);
  
      return rename(tmp_index, index);
  }
  
  int main(int argc, const char *argv[]) {
      //input parameters
      char inputFilename[MAX_FILENAME_LENGTH], playlistFilename[MAX_FILENAME_LENGTH], baseDirName[MAX_FILENAME_LENGTH], baseFileName[MAX_FILENAME_LENGTH];
      char baseFileExtension[5]; //either "ts", "aac" or "mp3"
      int segmentLength, outputStreams, verbosity, version;
  
  
  
      char currentOutputFileName[MAX_FILENAME_LENGTH];
      char tempPlaylistName[MAX_FILENAME_LENGTH];
  
  
      //these are used to determine the exact length of the current segment
      double prev_segment_time = 0;
      double segment_time;
      unsigned int actual_segment_durations[2048];
      double packet_time = 0;
  
      //new variables to keep track of output size
      double output_bytes = 0;
  
      unsigned int output_index = 1;
      AVOutputFormat *ofmt;
      AVFormatContext *ic = NULL;
      AVFormatContext *oc;
      AVStream *video_st = NULL;
      AVStream *audio_st = NULL;
      AVCodec *codec;
      int video_index;
      int audio_index;
      unsigned int first_segment = 1;
      unsigned int last_segment = 0;
      int write_index = 1;
      int decode_done;
      int ret;
      int i;
  
      unsigned char id3_tag[128];
      unsigned char * image_id3_tag;
  
      size_t id3_tag_size = 73;
      int newFile = 1; //a boolean value to flag when a new file needs id3 tag info in it
  
      if (parseCommandLine(inputFilename, playlistFilename, baseDirName, baseFileName, baseFileExtension, &outputStreams, &segmentLength, &verbosity, &version, argc, argv) != 0)
          return 0;
  
      if (version) {
          ffmpeg_version();
          return 0;
      }
  
  
      fprintf(stderr, "%s %s\n", playlistFilename, tempPlaylistName);
  
  
      image_id3_tag = malloc(IMAGE_ID3_SIZE);
      if (outputStreams == OUTPUT_STREAM_AUDIO)
          build_image_id3_tag(image_id3_tag);
      build_id3_tag((char *) id3_tag, id3_tag_size);
  
      snprintf(tempPlaylistName, strlen(playlistFilename) + strlen(baseDirName) + 1, "%s%s", baseDirName, playlistFilename);
      strncpy(playlistFilename, tempPlaylistName, strlen(tempPlaylistName));
      strncpy(tempPlaylistName, playlistFilename, MAX_FILENAME_LENGTH);
      strncat(tempPlaylistName, ".", 1);
  
      //decide if this is an aac file or a mpegts file.
      //postpone deciding format until later
      /*  ifmt = av_find_input_format("mpegts");
      if (!ifmt) 
      {
      fprintf(stderr, "Could not find MPEG-TS demuxer.\n");
      exit(1);
      } */
  
      av_log_set_level(AV_LOG_DEBUG);
  
      av_register_all();
      ret = avformat_open_input(&ic, inputFilename, NULL, NULL);
      if (ret != 0) {
          fprintf(stderr, "Could not open input file %s. Error %d.\n", inputFilename, ret);
          exit(1);
      }
  
      if (avformat_find_stream_info(ic, NULL) < 0) {
          fprintf(stderr, "Could not read stream information.\n");
          exit(1);
      }
  
      oc = avformat_alloc_context();
      if (!oc) {
          fprintf(stderr, "Could not allocate output context.");
          exit(1);
      }
  
      video_index = -1;
      audio_index = -1;
  
      for (i = 0; i < ic->nb_streams && (video_index < 0 || audio_index < 0); i++) {
          switch (ic->streams[i]->codec->codec_type) {
  
  #ifdef USE_OLD_FFMPEG
              case CODEC_TYPE_VIDEO:
  #else
              case AVMEDIA_TYPE_VIDEO:
  #endif
                  video_index = i;
                  ic->streams[i]->discard = AVDISCARD_NONE;
                  if (outputStreams & OUTPUT_STREAM_VIDEO)
                      video_st = add_output_stream(oc, ic->streams[i]);
                  break;
  #ifdef USE_OLD_FFMPEG
              case CODEC_TYPE_AUDIO:
  #else
              case AVMEDIA_TYPE_AUDIO:
  #endif
                  audio_index = i;
                  ic->streams[i]->discard = AVDISCARD_NONE;
                  if (outputStreams & OUTPUT_STREAM_AUDIO)
                      audio_st = add_output_stream(oc, ic->streams[i]);
                  break;
              default:
                  ic->streams[i]->discard = AVDISCARD_ALL;
                  break;
          }
      }
  
      if (video_index == -1) {
          fprintf(stderr, "Stream must have video component.\n");
          exit(1);
      }
  
      //now that we know the audio and video output streams
      //we can decide on an output format.
      if (outputStreams == OUTPUT_STREAM_AUDIO) {
          //the audio output format should be the same as the audio input format
          switch (ic->streams[audio_index]->codec->codec_id) {
              case CODEC_ID_MP3:
                  fprintf(stderr, "Setting output audio to mp3.");
                  strncpy(baseFileExtension, ".mp3", strlen(".mp3"));
                  ofmt = av_guess_format("mp3", NULL, NULL);
                  break;
              case CODEC_ID_AAC:
                  fprintf(stderr, "Setting output audio to aac.");
                  ofmt = av_guess_format("adts", NULL, NULL);
                  break;
              default:
                  fprintf(stderr, "Codec id %d not supported.\n", ic->streams[audio_index]->id);
          }
          if (!ofmt) {
              fprintf(stderr, "Could not find audio muxer.\n");
              exit(1);
          }
      } else {
          ofmt = av_guess_format("mpegts", NULL, NULL);
          if (!ofmt) {
              fprintf(stderr, "Could not find MPEG-TS muxer.\n");
              exit(1);
          }
      }
      oc->oformat = ofmt;
  
      if (outputStreams & OUTPUT_STREAM_VIDEO && oc->oformat->flags & AVFMT_GLOBALHEADER) {
          oc->flags |= CODEC_FLAG_GLOBAL_HEADER;
      }
  
  
      /*  Deprecated: pass the options to avformat_write_header directly. 
          if (av_set_parameters(oc, NULL) < 0) {
              fprintf(stderr, "Invalid output format parameters.\n");
              exit(1);
          }
       */
  
      av_dump_format(oc, 0, baseFileName, 1);
  
  
      //open the video codec only if there is video data
      if (video_index != -1) {
          if (outputStreams & OUTPUT_STREAM_VIDEO)
              codec = avcodec_find_decoder(video_st->codec->codec_id);
          else
              codec = avcodec_find_decoder(ic->streams[video_index]->codec->codec_id);
          if (!codec) {
              fprintf(stderr, "Could not find video decoder, key frames will not be honored.\n");
          }
  
          if (outputStreams & OUTPUT_STREAM_VIDEO)
              ret = avcodec_open2(video_st->codec, codec, NULL);
          else
              avcodec_open2(ic->streams[video_index]->codec, codec, NULL);
          if (ret < 0) {
              fprintf(stderr, "Could not open video decoder, key frames will not be honored.\n");
          }
      }
  
      snprintf(currentOutputFileName, strlen(baseDirName) + strlen(baseFileName) + strlen(baseFileExtension) + 10, "%s%s-%u%s", baseDirName, baseFileName, output_index++, baseFileExtension);
  
      if (avio_open(&oc->pb, currentOutputFileName, URL_WRONLY) < 0) {
          fprintf(stderr, "Could not open '%s'.\n", currentOutputFileName);
          exit(1);
      }
      newFile = 1;
  
      int r = avformat_write_header(oc,NULL);
      if (r) {
          fprintf(stderr, "Could not write mpegts header to first output file.\n");
          debugReturnCode(r);
          exit(1);
      }
  
      //no segment info is written here. This just creates the shell of the playlist file
      write_index = !write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);
  
      do {
          AVPacket packet;
  
          decode_done = av_read_frame(ic, &packet);
  
          if (decode_done < 0) {
              break;
          }
  
          if (av_dup_packet(&packet) < 0) {
              fprintf(stderr, "Could not duplicate packet.");
              av_free_packet(&packet);
              break;
          }
  
          //this time is used to check for a break in the segments
          //  if (packet.stream_index == video_index && (packet.flags & PKT_FLAG_KEY)) 
          //  {
          //    segment_time = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;         
          //  }
  #if USE_OLD_FFMPEG
          if (packet.stream_index == video_index && (packet.flags & PKT_FLAG_KEY))
  #else
          if (packet.stream_index == video_index && (packet.flags & AV_PKT_FLAG_KEY))
  #endif
          {
              segment_time = (double) packet.pts * ic->streams[video_index]->time_base.num / ic->streams[video_index]->time_base.den;
          }
          //  else if (video_index < 0) 
          //  {
          //      segment_time = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
          //  }
  
          //get the most recent packet time
          //this time is used when the time for the final segment is printed. It may not be on the edge of
          //of a keyframe!
          if (packet.stream_index == video_index)
              packet_time = (double) packet.pts * ic->streams[video_index]->time_base.num / ic->streams[video_index]->time_base.den; //(double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
          else if (outputStreams & OUTPUT_STREAM_AUDIO)
              packet_time = (double) audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
          else
              continue;
          //start looking for segment splits for videos one half second before segment duration expires. This is because the 
          //segments are split on key frames so we cannot expect all segments to be split exactly equally. 
          if (segment_time - prev_segment_time >= segmentLength - 0.5) {
              fprintf(stderr, "looking to print index file at time %lf\n", segment_time);
              avio_flush(oc->pb);
              avio_close(oc->pb);
  
              if (write_index) {
                  actual_segment_durations[++last_segment] = (unsigned int) rint(segment_time - prev_segment_time);
                  write_index = !write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);
                  fprintf(stderr, "Writing index file at time %lf\n", packet_time);
              }
  
              struct stat st;
              stat(currentOutputFileName, &st);
              output_bytes += st.st_size;
  
              snprintf(currentOutputFileName, strlen(baseDirName) + strlen(baseFileName) + strlen(baseFileExtension) + 10, "%s%s-%u%s", baseDirName, baseFileName, output_index++, baseFileExtension);
              if (avio_open(&oc->pb, currentOutputFileName, URL_WRONLY) < 0) {
                  fprintf(stderr, "Could not open '%s'\n", currentOutputFileName);
                  break;
              }
  
              newFile = 1;
              prev_segment_time = segment_time;
          }
  
          if (outputStreams == OUTPUT_STREAM_AUDIO && packet.stream_index == audio_index) {
              if (newFile && outputStreams == OUTPUT_STREAM_AUDIO) {
                  //add id3 tag info
                  //fprintf(stderr, "adding id3tag to file %s\n", currentOutputFileName);
                  //printf("%lf %lld %lld %lld %lld %lld %lf\n", segment_time, audio_st->pts.val, audio_st->cur_dts, audio_st->cur_pkt.pts, packet.pts, packet.dts, packet.dts * av_q2d(ic->streams[audio_index]->time_base) );
                  fill_id3_tag((char*) id3_tag, id3_tag_size, packet.dts);
                  avio_write(oc->pb, id3_tag, id3_tag_size);
                  avio_write(oc->pb, image_id3_tag, IMAGE_ID3_SIZE);
                  avio_flush(oc->pb);
                  newFile = 0;
              }
  
              packet.stream_index = 0; //only one stream in audio only segments
              ret = av_interleaved_write_frame(oc, &packet);
          } else if (outputStreams & OUTPUT_STREAM_VIDEO) {
              if (newFile) {
                  //fprintf(stderr, "New File: %lld %lld %lld\n", packet.pts, video_st->pts.val, audio_st->pts.val);
                  //printf("%lf %lld %lld %lld %lld %lld %lf\n", segment_time, audio_st->pts.val, audio_st->cur_dts, audio_st->cur_pkt.pts, packet.pts, packet.dts, packet.dts * av_q2d(ic->streams[audio_index]->time_base) );
                  newFile = 0;
              }
              if (outputStreams == OUTPUT_STREAM_VIDEO)
                  ret = av_write_frame(oc, &packet);
              else
                  ret = av_interleaved_write_frame(oc, &packet);
          }
  
          if (ret < 0) {
              fprintf(stderr, "Warning: Could not write frame of stream.\n");
          } else if (ret > 0) {
              fprintf(stderr, "End of stream requested.\n");
              av_free_packet(&packet);
              break;
          }
  
          av_free_packet(&packet);
      } while (!decode_done);
  
      //make sure all packets are written and then close the last file. 
      avio_flush(oc->pb);
      av_write_trailer(oc);
  
      if (video_st && video_st->codec)
          avcodec_close(video_st->codec);
  
      if (audio_st && audio_st->codec)
          avcodec_close(audio_st->codec);
  
      for (i = 0; i < oc->nb_streams; i++) {
          av_freep(&oc->streams[i]->codec);
          av_freep(&oc->streams[i]);
      }
  
      avio_close(oc->pb);
      av_free(oc);
  
      struct stat st;
      stat(currentOutputFileName, &st);
      output_bytes += st.st_size;
  
  
      if (write_index) {
          actual_segment_durations[++last_segment] = (unsigned int) rint(packet_time - prev_segment_time);
  
          //make sure that the last segment length is not zero
          if (actual_segment_durations[last_segment] == 0)
              actual_segment_durations[last_segment] = 1;
  
          write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);
  
      }
  
      write_stream_size_file(baseDirName, baseFileName, output_bytes * 8 / segment_time);
  
      return 0;
  }
  

• Grab frame without downloading whole file ?

  12 janvier 2012, par Writecoder

  Is this possible using php + ffmpeg?

  ffmpeg-php has the ability to:

  Ability to grab frames from movie files and return them as images that can be manipulated using PHP's built-in image functions. This is great for automatically creating thumbnails for movie files.

  I just don't want to download the whole file before doing so. So lets say i want to grab a frame @ 10% of the movie:

  First lets get the size of remote file:

  $ch = curl_init(); 
  curl_setopt($ch, CURLOPT_HEADER, true); 
  curl_setopt($ch, CURLOPT_NOBODY, true);
  curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true); 
  curl_setopt($ch, CURLOPT_URL, $url); //specify the url
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE); 
  $head = curl_exec($ch);
  
  $size = curl_getinfo($ch,CURLINFO_CONTENT_LENGTH_DOWNLOAD);
  

  Then it's quite easy to download only 10% of the .flv or .mov file using curl.

  But the framegrab trick using ffmpeg-php probably won't work because the file probably is corrupted?

  Any other ideas?

• Requesting header information of a file

  11 janvier 2012, par 0v3rrid3

  is there anyway I can request only the header information of any media. For example I just want to request header information of any video file so as to find its video length. I tried using ffmpeg -i {video_url} and did the work but I noticed that it actually downloads the given media in local storage and returns back the header information which obviously increases roundtrip time.

  So I would really appreciate if there is any idea for finding the length of media in a fly. BTW I have a ruby on rails application where I need to implement this.

• What are the APIs for hardware accelerated video decoding in phones ?

  11 janvier 2012, par cloudraven

  I have seen many smartphones coming with hardware accelerated video decoding supporting mpeg2 and h264, but unlike in desktop and laptop systems, it is not clear to me how to interact with the hardware acceleration. For desktops/laptops there is DXVA, VDPAU and OpenMax. Is any of those supported in Mobile phones? I think OpenMax is, but I am not sure of how widely supported it is.

  Is anyone familiar with what is usually used to write hardware accelerated media players and decoders for platforms like Snapdragon, Tegra 2 or Omap 4 running Android or Windows Phone? I know that ffmpeg can be compiled for arm and I wonder what kind of hardware video acceleration it supports on that platform.

• Problem in FFMPEG encoding decoding with IPhone os 4.3 SDK

  11 janvier 2012, par IPhoneUprise

  I want to convert my mov file (audio + video) in to mp4 to reduce file size in IPhone. I successfully compile FFMPEG libraries for armv7 for IPhone OS 4.3 sdk and i was able to decode and encode video frames in IPhone. Now my compressed file size reduced from 48 mb mov file to 2 mb mp4 file.But the audio is missing in compressed mp4 file, so now i am trying to decode and encode audio as well but i am getting issues to integrate this audio encode decode code with my existing code. If any one has any sample which shows how to encode decode audio with video that would be great.