Recherche avancée

Sur d’autres sites (6210)

• 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 <sys></sys>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 <infile>.\n");
  
      fprintf(stderr, "--o <outfile>.\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 &lt; 64k streams.\n");
  
      fprintf(stderr, "--v,  video only decode for &lt; 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) &amp;&amp; av_q2d(input_stream->time_base) &lt; 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 &amp;&amp; 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 &amp; 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 &lt;= 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 &lt;= 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, &amp;outputStreams, &amp;segmentLength, &amp;verbosity, &amp;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(&amp;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) &lt; 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 &lt; ic->nb_streams &amp;&amp; (video_index &lt; 0 || audio_index &lt; 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 &amp; 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 &amp; 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 &amp; OUTPUT_STREAM_VIDEO &amp;&amp; oc->oformat->flags &amp; AVFMT_GLOBALHEADER) {
  
          oc->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
      }
  
  
  
  
  
      /*  Deprecated: pass the options to avformat_write_header directly. 
  
          if (av_set_parameters(oc, NULL) &lt; 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 &amp; 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 &amp; OUTPUT_STREAM_VIDEO)
  
              ret = avcodec_open2(video_st->codec, codec, NULL);
  
          else
  
              avcodec_open2(ic->streams[video_index]->codec, codec, NULL);
  
          if (ret &lt; 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(&amp;oc->pb, currentOutputFileName, URL_WRONLY) &lt; 0) {
  
          fprintf(stderr, "Could not open &#39;%s&#39;.\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, &amp;packet);
  
  
  
          if (decode_done &lt; 0) {
  
              break;
  
          }
  
  
  
          if (av_dup_packet(&amp;packet) &lt; 0) {
  
              fprintf(stderr, "Could not duplicate packet.");
  
              av_free_packet(&amp;packet);
  
              break;
  
          }
  
  
  
          //this time is used to check for a break in the segments
  
          //  if (packet.stream_index == video_index &amp;&amp; (packet.flags &amp; 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 &amp;&amp; (packet.flags &amp; PKT_FLAG_KEY))
  
  #else
  
          if (packet.stream_index == video_index &amp;&amp; (packet.flags &amp; 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 &lt; 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 &amp; 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, &amp;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(&amp;oc->pb, currentOutputFileName, URL_WRONLY) &lt; 0) {
  
                  fprintf(stderr, "Could not open &#39;%s&#39;\n", currentOutputFileName);
  
                  break;
  
              }
  
  
  
              newFile = 1;
  
              prev_segment_time = segment_time;
  
          }
  
  
  
          if (outputStreams == OUTPUT_STREAM_AUDIO &amp;&amp; packet.stream_index == audio_index) {
  
              if (newFile &amp;&amp; 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, &amp;packet);
  
          } else if (outputStreams &amp; 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, &amp;packet);
  
              else
  
                  ret = av_interleaved_write_frame(oc, &amp;packet);
  
          }
  
  
  
          if (ret &lt; 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(&amp;packet);
  
              break;
  
          }
  
  
  
          av_free_packet(&amp;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 &amp;&amp; video_st->codec)
  
          avcodec_close(video_st->codec);
  
  
  
      if (audio_st &amp;&amp; audio_st->codec)
  
          avcodec_close(audio_st->codec);
  
  
  
      for (i = 0; i &lt; oc->nb_streams; i++) {
  
          av_freep(&amp;oc->streams[i]->codec);
  
          av_freep(&amp;oc->streams[i]);
  
      }
  
  
  
      avio_close(oc->pb);
  
      av_free(oc);
  
  
  
      struct stat st;
  
      stat(currentOutputFileName, &amp;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;
  
  }
  
  </outfile></infile>

• Announcing the World’s Worst VP8 Encoder

  5 octobre 2010, par Multimedia Mike — Outlandish Brainstorms, VP8

  I wanted to see if I could write an extremely basic VP8 encoder. It turned out to be one of the hardest endeavors I have ever attempted (and arguably one of the least successful).

  Results
  I started with the Big Buck Bunny title image :

  
  
  

  And this is the best encoding that this experiment could yield :

  
  
  

  Squint hard enough and you can totally make out the logo. Pretty silly effort, I know. It should also be noted that the resultant .webm file holding that single 400×225 image was 191324 bytes. When FFmpeg decoded it to a PNG, it was only 187200 bytes.

  The Story
  Remember my post about a naive SVQ1 encoder ? Long story short, I set out to do the same thing with VP8. (I wanted to the same thing with VP3/Theora for years. But take a good look at what it would entail to create even the most basic bitstream. As involved as VP8 may be, its bitstream is absolutely trivial compared to VP3/Theora.)
  

  With the naive SVQ1 encoder, the goal was to create a minimally compliant SVQ1 encoded bitstream. For this exercise, I similarly hypothesized what it would take to create the most basic, syntactically correct VP8 bitstream with the least amount of effort. These are the overall steps I came up with :

  • Intra-only
  • Create a basic bitstream header that disables any extra features (no modification of default tables)
  • Use a static quantizer
  • Use intra 16×16 coding for each macroblock
  • Use vertical prediction for the 16×16 intra coding

  For coding each macroblock :

  • Subtract vertical predictor from each row
  • Perform forward transform on each 4×4 sub block
  • Perform forward WHT on luma plane DCT coefficients
  • Pack the coefficients into the bitstream via the Boolean encoder

  It all sounds so simple. But, like I said in the SVQ1 post, it’s all very much like carefully bootstrapping a program to run on a particular CPU, and the VP8 decoder serves as the CPU. I’m confident that I have the bitstream encoding correct because, at the very least, the decoder agrees precisely with the encoder about the numbers represented by those 0s and 1s.

  What’s Wrong ?
  Compromises were made for the sake of getting some vaguely recognizable image encoded in a minimally valid manner. One big stumbling block is that I couldn’t seem to encode an end of block (EOB) condition correctly. I then realized that it’s perfectly valid to just encode a lot of zero coefficients rather than signaling EOB. An encoding travesty, I know, and likely one reason that the resulting filesize is so huge.

  More drama occurred when I hit my first block that had all zeros. There were complications in that situation that I couldn’t seem to avoid. So I forced the first AC coefficient to be 1 in that case. Hey, the decoder liked it.

  As for the generally weird look of the decoded image, I’m thinking that could either be : A) an artifact of forcing 16×16 vertical prediction or ; or B) a mistake in the way that I transformed and predicted stuff before sending it to the decoder. The smart money is on a combination of both A and B.

  Then again, as the SVQ1 experiment demonstrated, I shouldn’t expect extraordinary visual quality when setting the bar this low (i.e., just getting some bag of bits that doesn’t make the decoder barf).

• Stop doing this in your encoder comparisons

  14 juin 2010, par Dark Shikari — Uncategorized

  I’ll do a more detailed post later on how to properly compare encoders, but lately I’ve seen a lot of people doing something in particular that demonstrates they have no idea what they’re doing.

  PSNR is not a very good metric. But it’s useful for one thing : if every encoder optimizes for it, you can effectively measure how good those encoders are at optimizing for PSNR. Certainly this doesn’t tell you everything you want to know, but it can give you a good approximation of “how good the encoder is at optimizing for SOMETHING“. The hope is that this is decently close to the visual results. This of course can fail to be the case if one encoder has psy optimizations and the other does not.

  But it only works to begin with if both encoders are optimized for PSNR. If one optimizes for, say, SSIM, and one optimizes for PSNR, comparing PSNR numbers is completely meaningless. If anything, it’s worse than meaningless — it will bias enormously towards the encoder that is tuned towards PSNR, for obvious reasons.

  And yet people keep doing this.

  They keep comparing x264 against other encoders which are tuned against PSNR. But they don’t tell x264 to also tune for PSNR (–tune psnr, it’s not hard !), and surprise surprise, x264 loses. Of course, these people never bother to actually look at the output ; if they did, they’d notice that x264 usually looks quite a bit better despite having lower PSNR.

  This happens so often that I suspect this is largely being done intentionally in order to cheat in encoder comparisons. Or perhaps it’s because tons of people who know absolutely nothing about video coding insist on doing comparisons without checking their methodology. Whatever it is, it clearly demonstrates that the person doing the test doesn’t understand what PSNR is or why it is used.

  Another victim of this is Theora Ptalarbvorm, which optimizes for SSIM at the expense of PSNR — an absolutely great decision for visual quality. And of course if you just blindly compare Ptalarbvorm (1.2) and Thusnelda (1.1), you’ll notice Ptalarbvorm has much lower PSNR ! Clearly, it must be a worse encoder, right ?

  Stop doing this. And call out the people who insist on cheating.