ffmpeg update to june 23 version which fixes mp4 crash on still frames with 3...

source/patched-ffmpeg-mt/libavformat/mmst.c

 /*
  * MMS protocol over TCP
  * Copyright (c) 2006,2007 Ryan Martell
  * Copyright (c) 2007 Björn Axelsson
  * Copyright (c) 2010 Zhentan Feng <spyfeng at gmail dot com>
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 240 matching lines @@
             if(AV_RL32(mms->in_buffer + 4)==0xb00bface) {
                 mms->incoming_flags= mms->in_buffer[3];
                 read_result= url_read_complete(mms->mms_hd, mms->in_buffer+8, 4);
                 if(read_result == 4) {
                     int length_remaining= AV_RL32(mms->in_buffer+8) + 4;
 
                     dprintf(NULL, "Length remaining is %d\n", length_remaining);
                     // read the rest of the packet.
                     if (length_remaining < 0
                         || length_remaining > sizeof(mms->in_buffer) - 12) {
-                        dprintf("Incoming message len %d exceeds buffer len %d\n",
+                        dprintf(NULL, "Incoming message len %d exceeds buffer len %d\n",
                             length_remaining, sizeof(mms->in_buffer) - 12);
                         return -1;
                     }
                     read_result = url_read_complete(mms->mms_hd, mms->in_buffer + 12,
                                                   length_remaining) ;
                     if (read_result == length_remaining) {
                         packet_type= AV_RL16(mms->in_buffer+36);
                     } else {
                         dprintf(NULL, "read for packet type failed%d!\n", read_result);
                         return -1;
@@ skipping 12 matching lines @@
                 // note we cache the first 8 bytes,
                 // then fill up the buffer with the others
                 tmp                       = AV_RL16(mms->in_buffer + 6);
                 length_remaining          = (tmp - 8) & 0xffff;
                 mms->incoming_packet_seq  = AV_RL32(mms->in_buffer);
                 packet_id_type            = mms->in_buffer[4];
                 mms->incoming_flags       = mms->in_buffer[5];
 
                 if (length_remaining < 0
                         || length_remaining > sizeof(mms->in_buffer) - 8) {
-                    dprintf("Incoming data len %d exceeds buffer len %d\n",
+                    dprintf(NULL, "Incoming data len %d exceeds buffer len %d\n",
                             length_remaining, sizeof(mms->in_buffer));
                     return -1;
                 }
                 mms->remaining_in_len    = length_remaining;
                 mms->read_in_ptr         = mms->in_buffer;
                 read_result= url_read_complete(mms->mms_hd, mms->in_buffer, length_remaining);
                 if(read_result != length_remaining) {
                     dprintf(NULL, "read_bytes result: %d asking for %d\n",
                             read_result, length_remaining);
                     return -1;
@@ skipping 119 matching lines @@
         memcmp(p, ff_asf_header, sizeof(ff_asf_guid)))
         return -1;
 
     real_header_size = AV_RL64(p + sizeof(ff_asf_guid));
     end = mms->asf_header + real_header_size;
 
     p += sizeof(ff_asf_guid) + 14;
     while(end - p >= sizeof(ff_asf_guid) + 8) {
         uint64_t chunksize = AV_RL64(p + sizeof(ff_asf_guid));
         if (!chunksize || chunksize > end - p) {
-            dprintf("chunksize is exceptional value:%d!\n", chunksize);
+            dprintf(NULL, "chunksize is exceptional value:%d!\n", chunksize);
             return -1;
         }
         if (!memcmp(p, ff_asf_file_header, sizeof(ff_asf_guid))) {
             /* read packet size */
             if (end - p > sizeof(ff_asf_guid) * 2 + 68) {
                 mms->asf_packet_len = AV_RL32(p + sizeof(ff_asf_guid) * 2 + 64);
                 if (mms->asf_packet_len <= 0 || mms->asf_packet_len > sizeof(mms->in_buffer)) {
                     dprintf(NULL,"Too large packet len:%d"
                         " may overwrite in_buffer when padding", mms->asf_packet_len);
                     return -1;
                 }
             }
         } else if (!memcmp(p, ff_asf_stream_header, sizeof(ff_asf_guid))) {
             flags     = AV_RL16(p + sizeof(ff_asf_guid)*3 + 24);
             stream_id = flags & 0x7F;
             //The second condition is for checking CS_PKT_STREAM_ID_REQUEST packet size,
             //we can calcuate the packet size by stream_num.
             //Please see function send_stream_selection_request().
             if (mms->stream_num < MAX_STREAMS &&
                     46 + mms->stream_num * 6 < sizeof(mms->out_buffer)) {
                 mms->streams[mms->stream_num].id = stream_id;
                 mms->stream_num++;
             } else {
-                dprintf("Too many streams.\n");
+                dprintf(NULL, "Too many streams.\n");
                 return -1;
             }
         }
         p += chunksize;
     }
 
     return 0;
 }
 
 /** Send MMST stream selection command based on the AVStream->discard values. */
@@ skipping 212 matching lines @@
 }
 
 URLProtocol mmst_protocol = {
     "mmst",
     mms_open,
     mms_read,
     NULL, // write
     NULL, // seek
     mms_close,
 };