API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 22nd, 2017
84
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 32.05 KB | None | 0 0
raw download clone embed print report
  1. libav instances of ignoring AV_LOG_ERROR-associated return values from non-void functions
  2. =========================================================================================
  3.  
  4. Conservative heuristics applied to filter out call sites testing, assigning, or returning
  5. AV_LOG_ERROR-associated callee return values. Many false negatives disappear and few false
  6. positives appear as well. For ffmpeg.c to pick up these in ways other than scanning av_log
  7. output for AV_LOG_ERROR-tagged messages requires every function in the call graph implied
  8. to transmit these return values. AV_LOG_ERRORs can occur in all listed functions directly
  9. or indirectly. This currently limits the utility of ffmpeg -xerror. Data derived from gcc
  10. using -fdump-rtl-expand and changing AV_LOG_ERROR to be a const int rather than a define.
  11.  
  12. MPV_common_init called from:
  13. libavcodec/mpegvideo.c:480 (ff_mpeg_update_thread_context):
  14. s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
  15.  
  16. MPV_common_init(s);
  17. }
  18.  
  19.  
  20.  
  21. T.117 called from:
  22. libavutil/opt.c:459 (av_opt_set_defaults):
  23. break;
  24. case FF_OPT_TYPE_STRING:
  25. av_set_string3(s, opt->name, opt->default_val.str, 1, NULL);
  26. break;
  27. case FF_OPT_TYPE_BINARY:
  28.  
  29. libavutil/opt.c:459 (av_opt_set_defaults2):
  30. break;
  31. case FF_OPT_TYPE_STRING:
  32. av_set_string3(s, opt->name, opt->default_val.str, 1, NULL);
  33. break;
  34. case FF_OPT_TYPE_BINARY:
  35.  
  36.  
  37. T.131 called from:
  38. libswscale/utils.c:1204 (sws_getContext):
  39. c->param[1] = param[1];
  40. }
  41. sws_setColorspaceDetails(c, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], c->srcRange, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT] /* FIXME*/, c->dstRange, 0, 1<<16, 1<<16);
  42.  
  43. if(sws_init_context(c, srcFilter, dstFilter) < 0){
  44.  
  45. libswscale/utils.c:1603 (sws_getCachedContext):
  46. context->param[0] = param[0];
  47. context->param[1] = param[1];
  48. sws_setColorspaceDetails(context, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], context->srcRange, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT] /* FIXME*/, context->dstRange, 0, 1<<16, 1<<16);
  49. if (sws_init_context(context, srcFilter, dstFilter) < 0) {
  50. sws_freeContext(context);
  51.  
  52.  
  53. T.217 called from:
  54. libavcodec/mjpegdec.c:66 (build_basic_mjpeg_vlc):
  55.  
  56. static void build_basic_mjpeg_vlc(MJpegDecodeContext * s) {
  57. build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance,
  58. ff_mjpeg_val_dc, 12, 0, 0);
  59. build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance,
  60.  
  61. libavcodec/mjpegdec.c:68 (build_basic_mjpeg_vlc):
  62. build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance,
  63. ff_mjpeg_val_dc, 12, 0, 0);
  64. build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance,
  65. ff_mjpeg_val_dc, 12, 0, 0);
  66. build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance,
  67.  
  68. libavcodec/mjpegdec.c:70 (build_basic_mjpeg_vlc):
  69. build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance,
  70. ff_mjpeg_val_dc, 12, 0, 0);
  71. build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance,
  72. ff_mjpeg_val_ac_luminance, 251, 0, 1);
  73. build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance,
  74.  
  75. libavcodec/mjpegdec.c:72 (build_basic_mjpeg_vlc):
  76. build_vlc(&s->vlcs[1][0], ff_mjpeg_bits_ac_luminance,
  77. ff_mjpeg_val_ac_luminance, 251, 0, 1);
  78. build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance,
  79. ff_mjpeg_val_ac_chrominance, 251, 0, 1);
  80. build_vlc(&s->vlcs[2][0], ff_mjpeg_bits_ac_luminance,
  81.  
  82. libavcodec/mjpegdec.c:74 (build_basic_mjpeg_vlc):
  83. build_vlc(&s->vlcs[1][1], ff_mjpeg_bits_ac_chrominance,
  84. ff_mjpeg_val_ac_chrominance, 251, 0, 1);
  85. build_vlc(&s->vlcs[2][0], ff_mjpeg_bits_ac_luminance,
  86. ff_mjpeg_val_ac_luminance, 251, 0, 0);
  87. build_vlc(&s->vlcs[2][1], ff_mjpeg_bits_ac_chrominance,
  88.  
  89. libavcodec/mjpegdec.c:76 (build_basic_mjpeg_vlc):
  90. build_vlc(&s->vlcs[2][0], ff_mjpeg_bits_ac_luminance,
  91. ff_mjpeg_val_ac_luminance, 251, 0, 0);
  92. build_vlc(&s->vlcs[2][1], ff_mjpeg_bits_ac_chrominance,
  93. ff_mjpeg_val_ac_chrominance, 251, 0, 0);
  94. }
  95.  
  96.  
  97. T.49 called from:
  98. libavformat/rmenc.c:452 (rm_write_trailer):
  99. for(i=0;i<s->nb_streams;i++)
  100. rm->streams[i].total_frames = rm->streams[i].nb_frames;
  101. rv10_write_header(s, data_size, 0);
  102. } else {
  103. /* undocumented end header */
  104.  
  105.  
  106. av_set_string3 called from:
  107. cmdutils.c:468 (set_context_opts):
  108. /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
  109. if(str && ((opt->flags & flags) == flags))
  110. av_set_string3(ctx, opt_names[i], str, 1, NULL);
  111. /* We need to use a differnt system to pass options to the private context because
  112. it is not known which codec and thus context kind that will be when parsing options
  113.  
  114. cmdutils.c:473 (set_context_opts):
  115. we thus use opt_values directly instead of opts_ctx */
  116. if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
  117. av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
  118. }
  119. }
  120.  
  121.  
  122. avpicture_fill called from:
  123. libavcodec/rawdec.c:157 (raw_decode):
  124. return -1;
  125.  
  126. avpicture_fill(picture, buf, avctx->pix_fmt, avctx->width, avctx->height);
  127. if((avctx->pix_fmt==PIX_FMT_PAL8 && buf_size < context->length) ||
  128. (avctx->pix_fmt!=PIX_FMT_PAL8 &&
  129.  
  130.  
  131. dca_decode_block called from:
  132. libavcodec/dca.c:1658 (dca_decode_frame):
  133.  
  134. for (i = 0; i < (s->sample_blocks / 8); i++) {
  135. dca_decode_block(s, 0, i);
  136. }
  137.  
  138.  
  139. libavcodec/dca.c:1714 (dca_decode_frame):
  140.  
  141. for (i = 0; i < (s->sample_blocks / 8); i++) {
  142. dca_decode_block(s, s->xch_base_channel, i);
  143. }
  144.  
  145.  
  146.  
  147. decode_audio_specific_config called from:
  148. libavcodec/aacdec.c:2320 (latm_decode_audio_specific_config):
  149. } else {
  150. bits_consumed =
  151. decode_audio_specific_config(NULL, avctx, &m4ac,
  152. gb->buffer + (config_start_bit / 8),
  153. get_bits_left(gb) / 8);
  154.  
  155.  
  156. decode_chunks called from:
  157. libavcodec/mpeg12.c:2281 (mpeg_decode_frame):
  158.  
  159. if(avctx->extradata && !avctx->frame_number)
  160. decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
  161.  
  162. return decode_chunks(avctx, picture, data_size, buf, buf_size);
  163.  
  164.  
  165. decode_frame called from:
  166. libavcodec/wmaprodec.c:1536 (decode_packet):
  167. /** decode the cross packet frame if it is valid */
  168. if (!s->packet_loss)
  169. decode_frame(s);
  170. } else if (s->num_saved_bits - s->frame_offset) {
  171. av_dlog(avctx, "ignoring %x previously saved bits\n",
  172.  
  173.  
  174. decode_info_header called from:
  175. libavformat/nutdec.c:647 (nut_read_header):
  176. }
  177.  
  178. decode_info_header(nut);
  179. }
  180.  
  181.  
  182.  
  183. decode_init called from:
  184. libavcodec/mpegaudiodec.c:1950 (decode_init_mp3on4):
  185. // Put decoder context in place to make init_decode() happy
  186. avctx->priv_data = s->mp3decctx[0];
  187. decode_init(avctx);
  188. // Restore mp3on4 context pointer
  189. avctx->priv_data = s;
  190.  
  191.  
  192. decode_mb_i called from:
  193. libavcodec/cavsdec.c:552 (cavs_decode_frame):
  194. do {
  195. check_for_slice(h);
  196. decode_mb_i(h, 0);
  197. } while(ff_cavs_next_mb(h));
  198. } else if(h->pic_type == AV_PICTURE_TYPE_P) {
  199.  
  200. libavcodec/cavsdec.c:565 (cavs_decode_frame):
  201. mb_type = get_ue_golomb(&s->gb) + P_SKIP + h->skip_mode_flag;
  202. if(mb_type > P_8X8)
  203. decode_mb_i(h, mb_type - P_8X8 - 1);
  204. else
  205. decode_mb_p(h,mb_type);
  206.  
  207. libavcodec/cavsdec.c:581 (cavs_decode_frame):
  208. mb_type = get_ue_golomb(&s->gb) + B_SKIP + h->skip_mode_flag;
  209. if(mb_type > B_8X8)
  210. decode_mb_i(h, mb_type - B_8X8 - 1);
  211. else
  212. decode_mb_b(h,mb_type);
  213.  
  214.  
  215. decode_residual_block called from:
  216. libavcodec/cavsdec.c:154 (decode_mb_b):
  217. static inline void decode_residual_chroma(AVSContext *h) {
  218. if(h->cbp & (1<<4))
  219. decode_residual_block(h,&h->s.gb,ff_cavs_chroma_dec,0,
  220. ff_cavs_chroma_qp[h->qp],h->cu,h->c_stride);
  221. if(h->cbp & (1<<5))
  222.  
  223. libavcodec/cavsdec.c:154 (decode_mb_p):
  224. static inline void decode_residual_chroma(AVSContext *h) {
  225. if(h->cbp & (1<<4))
  226. decode_residual_block(h,&h->s.gb,ff_cavs_chroma_dec,0,
  227. ff_cavs_chroma_qp[h->qp],h->cu,h->c_stride);
  228. if(h->cbp & (1<<5))
  229.  
  230. libavcodec/cavsdec.c:157 (decode_mb_b):
  231. ff_cavs_chroma_qp[h->qp],h->cu,h->c_stride);
  232. if(h->cbp & (1<<5))
  233. decode_residual_block(h,&h->s.gb,ff_cavs_chroma_dec,0,
  234. ff_cavs_chroma_qp[h->qp],h->cv,h->c_stride);
  235. }
  236.  
  237. libavcodec/cavsdec.c:157 (decode_mb_p):
  238. ff_cavs_chroma_qp[h->qp],h->cu,h->c_stride);
  239. if(h->cbp & (1<<5))
  240. decode_residual_block(h,&h->s.gb,ff_cavs_chroma_dec,0,
  241. ff_cavs_chroma_qp[h->qp],h->cv,h->c_stride);
  242. }
  243.  
  244. libavcodec/cavsdec.c:177 (decode_mb_b):
  245. for(block=0;block<4;block++)
  246. if(h->cbp & (1<<block))
  247. decode_residual_block(h,&h->s.gb,ff_cavs_inter_dec,0,h->qp,
  248. h->cy + h->luma_scan[block], h->l_stride);
  249. decode_residual_chroma(h);
  250.  
  251. libavcodec/cavsdec.c:177 (decode_mb_p):
  252. for(block=0;block<4;block++)
  253. if(h->cbp & (1<<block))
  254. decode_residual_block(h,&h->s.gb,ff_cavs_inter_dec,0,h->qp,
  255. h->cy + h->luma_scan[block], h->l_stride);
  256. decode_residual_chroma(h);
  257.  
  258.  
  259. decode_slice called from:
  260. libavcodec/h263dec.c:641 (ff_h263_decode_frame):
  261. s->mb_y=0;
  262.  
  263. decode_slice(s);
  264. while(s->mb_y<s->mb_height){
  265. if(s->msmpeg4_version){
  266.  
  267. libavcodec/h263dec.c:657 (ff_h263_decode_frame):
  268. ff_mpeg4_clean_buffers(s);
  269.  
  270. decode_slice(s);
  271. }
  272.  
  273.  
  274. libavcodec/h264.c:3557 (decode_nal_units):
  275. return;
  276. if(context_count == 1) {
  277. decode_slice(avctx, &h);
  278. } else {
  279. for(i = 1; i < context_count; i++) {
  280.  
  281.  
  282. dv1394_start called from:
  283. libavdevice/dv1394.c:157 (dv1394_read_packet):
  284.  
  285. dv1394_reset(dv);
  286. dv1394_start(dv);
  287. }
  288. dv->done = 0;
  289.  
  290. libavdevice/dv1394.c:194 (dv1394_read_packet):
  291.  
  292. dv1394_reset(dv);
  293. dv1394_start(dv);
  294. }
  295. }
  296.  
  297.  
  298. encode_422_bitstream called from:
  299. libavcodec/huffyuv.c:1271 (encode_frame):
  300. leftv= sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
  301.  
  302. encode_422_bitstream(s, 2, width-2);
  303.  
  304. if(s->predictor==MEDIAN){
  305.  
  306. libavcodec/huffyuv.c:1281 (encode_frame):
  307. leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
  308.  
  309. encode_422_bitstream(s, 0, width);
  310. y++; cy++;
  311. }
  312.  
  313. libavcodec/huffyuv.c:1289 (encode_frame):
  314. leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
  315.  
  316. encode_422_bitstream(s, 0, 4);
  317.  
  318. lefttopy= p->data[0][3];
  319.  
  320. libavcodec/huffyuv.c:1297 (encode_frame):
  321. s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
  322. s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
  323. encode_422_bitstream(s, 0, width-4);
  324. y++; cy++;
  325.  
  326.  
  327. libavcodec/huffyuv.c:1320 (encode_frame):
  328. s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
  329.  
  330. encode_422_bitstream(s, 0, width);
  331. }
  332. }else{
  333.  
  334. libavcodec/huffyuv.c:1360 (encode_frame):
  335. }
  336.  
  337. encode_422_bitstream(s, 0, width);
  338. }
  339. }
  340.  
  341.  
  342. encode_bgr_bitstream called from:
  343. libavcodec/huffyuv.c:1376 (encode_frame):
  344.  
  345. sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
  346. encode_bgr_bitstream(s, width-1);
  347.  
  348. for(y=1; y<s->height; y++){
  349.  
  350. libavcodec/huffyuv.c:1386 (encode_frame):
  351. sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
  352. }
  353. encode_bgr_bitstream(s, width);
  354. }
  355. }else{
  356.  
  357.  
  358. encode_gray_bitstream called from:
  359. libavcodec/huffyuv.c:1307 (encode_frame):
  360. ydst= p->data[0] + p->linesize[0]*y;
  361. s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
  362. encode_gray_bitstream(s, width);
  363. y++;
  364. }
  365.  
  366. libavcodec/huffyuv.c:1337 (encode_frame):
  367. lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
  368. }
  369. encode_gray_bitstream(s, width);
  370. y++;
  371. if(y>=height) break;
  372.  
  373.  
  374. encode_mb called from:
  375. libavcodec/asv1.c:479 (encode_frame):
  376. for(mb_x=0; mb_x<a->mb_width2; mb_x++){
  377. dct_get(a, mb_x, mb_y);
  378. encode_mb(a, a->block);
  379. }
  380. }
  381.  
  382. libavcodec/asv1.c:487 (encode_frame):
  383. for(mb_y=0; mb_y<a->mb_height2; mb_y++){
  384. dct_get(a, mb_x, mb_y);
  385. encode_mb(a, a->block);
  386. }
  387. }
  388.  
  389. libavcodec/asv1.c:495 (encode_frame):
  390. for(mb_x=0; mb_x<a->mb_width; mb_x++){
  391. dct_get(a, mb_x, mb_y);
  392. encode_mb(a, a->block);
  393. }
  394. }
  395.  
  396.  
  397. ff_eval_refl called from:
  398. libavcodec/ra144enc.c:480 (ra144_encode_frame):
  399. */
  400. ff_int_to_int16(block_coefs[NBLOCKS - 1], ractx->lpc_coef[1]);
  401. ff_eval_refl(lpc_refl, block_coefs[NBLOCKS - 1], avctx);
  402. }
  403. init_put_bits(&pb, frame, buf_size);
  404.  
  405.  
  406. ff_h264_alloc_tables called from:
  407. libavcodec/h264.c:1159 (decode_update_thread_context):
  408. memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
  409. memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
  410. ff_h264_alloc_tables(h);
  411. context_init(h);
  412.  
  413.  
  414. libavcodec/h264.c:2629 (decode_slice_header):
  415.  
  416. init_scan_tables(h);
  417. ff_h264_alloc_tables(h);
  418.  
  419. if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) {
  420.  
  421. libavcodec/svq3.c:925 (svq3_decode_init):
  422. h->b_stride = 4*s->mb_width;
  423.  
  424. ff_h264_alloc_tables(h);
  425. }
  426.  
  427.  
  428.  
  429. ff_h264_check_intra4x4_pred_mode called from:
  430. libavcodec/svq3.c:595 (svq3_decode_frame):
  431.  
  432. if (mb_type == 8) {
  433. ff_h264_check_intra4x4_pred_mode(h);
  434.  
  435. h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
  436.  
  437.  
  438. ff_h264_decode_extradata called from:
  439. libavcodec/h264.c:1090 (ff_h264_decode_init):
  440.  
  441. if(avctx->extradata_size > 0 && avctx->extradata &&
  442. ff_h264_decode_extradata(h))
  443. return -1;
  444.  
  445.  
  446.  
  447. ff_h264_decode_ref_pic_marking called from:
  448. libavcodec/h264.c:2878 (decode_slice_header):
  449.  
  450. if(h->nal_ref_idc)
  451. ff_h264_decode_ref_pic_marking(h0, &s->gb);
  452.  
  453. if(FRAME_MBAFF){
  454.  
  455.  
  456. ff_h264_decode_sei called from:
  457. libavcodec/h264.c:3761 (decode_nal_units):
  458. case NAL_SEI:
  459. init_get_bits(&s->gb, ptr, bit_length);
  460. ff_h264_decode_sei(h);
  461. break;
  462. case NAL_SPS:
  463.  
  464.  
  465. ff_h264_execute_ref_pic_marking called from:
  466. libavcodec/h264.c:1215 (decode_update_thread_context):
  467.  
  468. if(!s->dropable) {
  469. ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
  470. h->prev_poc_msb = h->poc_msb;
  471. h->prev_poc_lsb = h->poc_lsb;
  472.  
  473. libavcodec/h264.c:2367 (field_end):
  474. if(in_setup || !(avctx->active_thread_type&FF_THREAD_FRAME)){
  475. if(!s->dropable) {
  476. ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
  477. h->prev_poc_msb= h->poc_msb;
  478. h->prev_poc_lsb= h->poc_lsb;
  479.  
  480. libavcodec/h264.c:2703 (decode_slice_header):
  481. ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);
  482. ff_generate_sliding_window_mmcos(h);
  483. ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
  484. /* Error concealment: if a ref is missing, copy the previous ref in its place.
  485. * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions
  486.  
  487.  
  488. ff_huff_build_tree called from:
  489. libavcodec/vp6.c:233 (vp6_parse_coeff_models):
  490. free_vlc(vlc);
  491. /* then build the huffman tree accodring to probabilities */
  492. ff_huff_build_tree(s->avctx, vlc, size, nodes, vp6_huff_cmp,
  493. FF_HUFFMAN_FLAG_HNODE_FIRST);
  494. }
  495.  
  496.  
  497. ff_init_me called from:
  498. libavcodec/snow.c:3484 (encode_frame):
  499.  
  500. s->m.dsp= s->dsp; //move
  501. ff_init_me(&s->m);
  502. s->dsp= s->m.dsp;
  503. }
  504.  
  505. libavcodec/svq1enc.c:326 (svq1_encode_plane):
  506. s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
  507. s->m.dsp= s->dsp; //move
  508. ff_init_me(&s->m);
  509.  
  510. s->m.me.dia_size= s->avctx->dia_size;
  511.  
  512.  
  513. ff_mjpeg_decode_dht called from:
  514. libavcodec/mjpegbdec.c:93 (mjpegb_decode_frame):
  515. init_get_bits(&s->gb, buf_ptr+dht_offs, (buf_end - (buf_ptr+dht_offs))*8);
  516. s->start_code = DHT;
  517. ff_mjpeg_decode_dht(s);
  518. }
  519.  
  520.  
  521.  
  522. ff_mjpeg_decode_dqt called from:
  523. libavcodec/mjpegbdec.c:84 (mjpegb_decode_frame):
  524. init_get_bits(&s->gb, buf_ptr+dqt_offs, (buf_end - (buf_ptr+dqt_offs))*8);
  525. s->start_code = DQT;
  526. ff_mjpeg_decode_dqt(s);
  527. }
  528.  
  529.  
  530.  
  531. ff_mjpeg_decode_init called from:
  532. libavcodec/mxpegdec.c:50 (mxpeg_decode_init):
  533. s->picture[0].reference = s->picture[1].reference = 3;
  534. s->jpg.picture_ptr = &s->picture[0];
  535. ff_mjpeg_decode_init(avctx);
  536.  
  537. return 0;
  538.  
  539.  
  540. ff_mjpeg_decode_sos called from:
  541. libavcodec/mjpegbdec.c:116 (mjpegb_decode_frame):
  542. s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
  543. s->start_code = SOS;
  544. ff_mjpeg_decode_sos(s, NULL, NULL);
  545. }
  546.  
  547.  
  548. libavcodec/mxpegdec.c:278 (mxpeg_decode_frame):
  549. }
  550.  
  551. ff_mjpeg_decode_sos(jpg, s->mxm_bitmask, reference_ptr);
  552. } else {
  553. ff_mjpeg_decode_sos(jpg, NULL, NULL);
  554.  
  555. libavcodec/mxpegdec.c:280 (mxpeg_decode_frame):
  556. ff_mjpeg_decode_sos(jpg, s->mxm_bitmask, reference_ptr);
  557. } else {
  558. ff_mjpeg_decode_sos(jpg, NULL, NULL);
  559. }
  560.  
  561.  
  562.  
  563. ff_mov_write_packet called from:
  564. libavformat/movenc.c:2122 (mov_write_header):
  565. AV_WB16(pkt.data, len);
  566. memcpy(pkt.data+2, t->value, len);
  567. ff_mov_write_packet(s, &pkt);
  568. av_freep(&pkt.data);
  569. }
  570.  
  571. libavformat/movenchint.c:435 (ff_mov_add_hinted_packet):
  572. hint_pkt.flags |= AV_PKT_FLAG_KEY;
  573. if (count > 0)
  574. ff_mov_write_packet(s, &hint_pkt);
  575. done:
  576. av_free(buf);
  577.  
  578.  
  579. ff_mpeg1_decode_block_intra called from:
  580. libavcodec/eatqi.c:67 (tqi_decode_frame):
  581. s->dsp.clear_blocks(block[0]);
  582. for (n=0; n<6; n++)
  583. ff_mpeg1_decode_block_intra(s, block[n], n);
  584. }
  585.  
  586.  
  587.  
  588. ff_msrle_decode called from:
  589. libavcodec/aasc.c:87 (aasc_decode_frame):
  590. break;
  591. case 1:
  592. ff_msrle_decode(avctx, (AVPicture*)&s->frame, 8, buf - 4, buf_size + 4);
  593. break;
  594. default:
  595.  
  596. libavcodec/bmp.c:260 (bmp_decode_frame):
  597. p->linesize[0] = -p->linesize[0];
  598. }
  599. ff_msrle_decode(avctx, (AVPicture*)p, depth, buf, dsize);
  600. if(height < 0){
  601. p->data[0] += p->linesize[0] * (avctx->height - 1);
  602.  
  603. libavcodec/msrle.c:126 (msrle_decode_frame):
  604. }
  605. } else {
  606. ff_msrle_decode(avctx, (AVPicture*)&s->frame, avctx->bits_per_coded_sample, buf, buf_size);
  607. }
  608.  
  609.  
  610.  
  611. ff_rtsp_send_cmd called from:
  612. libavformat/rtspdec.c:67 (rtsp_read_play):
  613. rt->seek_timestamp / (AV_TIME_BASE / 1000) % 1000);
  614. }
  615. ff_rtsp_send_cmd(s, "PLAY", rt->control_uri, cmd, reply, NULL);
  616. if (reply->status_code != RTSP_STATUS_OK) {
  617. return -1;
  618.  
  619. libavformat/rtspdec.c:99 (rtsp_read_packet):
  620. return 0;
  621. else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
  622. ff_rtsp_send_cmd(s, "PAUSE", rt->control_uri, NULL, reply, NULL);
  623. if (reply->status_code != RTSP_STATUS_OK) {
  624. return -1;
  625.  
  626. libavformat/rtspdec.c:99 (rtsp_read_pause):
  627. return 0;
  628. else if (!(rt->server_type == RTSP_SERVER_REAL && rt->need_subscription)) {
  629. ff_rtsp_send_cmd(s, "PAUSE", rt->control_uri, NULL, reply, NULL);
  630. if (reply->status_code != RTSP_STATUS_OK) {
  631. return -1;
  632.  
  633. libavformat/rtspdec.c:127 (ff_rtsp_setup_input_streams):
  634. sizeof(cmd));
  635. }
  636. ff_rtsp_send_cmd(s, "DESCRIBE", rt->control_uri, cmd, reply, &content);
  637. if (!content)
  638. return AVERROR_INVALIDDATA;
  639.  
  640. libavformat/rtspdec.c:268 (rtsp_read_packet):
  641. "Unsubscribe: %s\r\n",
  642. rt->last_subscription);
  643. ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
  644. cmd, reply, NULL);
  645. if (reply->status_code != RTSP_STATUS_OK)
  646.  
  647. libavformat/rtspdec.c:303 (rtsp_read_packet):
  648. }
  649. av_strlcatf(cmd, sizeof(cmd), "%s\r\n", rt->last_subscription);
  650. ff_rtsp_send_cmd(s, "SET_PARAMETER", rt->control_uri,
  651. cmd, reply, NULL);
  652. if (reply->status_code != RTSP_STATUS_OK)
  653.  
  654. libavformat/rtspdec.c:326 (rtsp_read_packet):
  655. // other servers close the connection.
  656. if (rt->server_type == RTSP_SERVER_REAL)
  657. ff_rtsp_send_cmd(s, "TEARDOWN", rt->control_uri, NULL,
  658. reply, NULL);
  659. rt->session_id[0] = '\0';
  660.  
  661. libavformat/rtspenc.c:123 (rtsp_write_record):
  662. snprintf(cmd, sizeof(cmd),
  663. "Range: npt=0.000-\r\n");
  664. ff_rtsp_send_cmd(s, "RECORD", rt->control_uri, cmd, reply, NULL);
  665. if (reply->status_code != RTSP_STATUS_OK)
  666. return -1;
  667.  
  668.  
  669. ff_rtsp_send_cmd_with_content called from:
  670. libavformat/rtspenc.c:88 (ff_rtsp_setup_output_streams):
  671. }
  672. av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp);
  673. ff_rtsp_send_cmd_with_content(s, "ANNOUNCE", rt->control_uri,
  674. "Content-Type: application/sdp\r\n",
  675. reply, NULL, sdp, strlen(sdp));
  676.  
  677.  
  678. ff_rv34_decode_init called from:
  679. libavcodec/rv30.c:249 (rv30_decode_init):
  680.  
  681. r->rv30 = 1;
  682. ff_rv34_decode_init(avctx);
  683. if(avctx->extradata_size < 2){
  684. av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
  685.  
  686. libavcodec/rv40.c:659 (rv40_decode_init):
  687.  
  688. r->rv30 = 0;
  689. ff_rv34_decode_init(avctx);
  690. if(!aic_top_vlc.bits)
  691. rv40_init_tables();
  692.  
  693.  
  694. ff_udp_set_remote_url called from:
  695. libavformat/rtpproto.c:76 (rtp_set_remote_url):
  696.  
  697. ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port, "%s", path);
  698. ff_udp_set_remote_url(s->rtp_hd, buf);
  699.  
  700. ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port + 1, "%s", path);
  701.  
  702. libavformat/rtpproto.c:79 (rtp_set_remote_url):
  703.  
  704. ff_url_join(buf, sizeof(buf), "udp", NULL, hostname, port + 1, "%s", path);
  705. ff_udp_set_remote_url(s->rtcp_hd, buf);
  706. return 0;
  707. }
  708.  
  709.  
  710. ff_wms_parse_sdp_a_line called from:
  711. libavformat/rtsp.c:415 (ff_sdp_parse):
  712. } else {
  713. if (rt->server_type == RTSP_SERVER_WMS)
  714. ff_wms_parse_sdp_a_line(s, p);
  715. if (s->nb_streams > 0) {
  716. if (rt->server_type == RTSP_SERVER_REAL)
  717.  
  718.  
  719. ff_yuv2rgb_c_init_tables called from:
  720. libswscale/utils.c:729 (T.131):
  721. c->srcFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[c->srcFormat]);
  722.  
  723. ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness, contrast, saturation);
  724. //FIXME factorize
  725.  
  726.  
  727. libswscale/utils.c:729 (sws_setColorspaceDetails):
  728. c->srcFormatBpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[c->srcFormat]);
  729.  
  730. ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness, contrast, saturation);
  731. //FIXME factorize
  732.  
  733.  
  734.  
  735. frame_start called from:
  736. libavcodec/snow.c:3441 (encode_frame):
  737. }//else keep previous frame's qlog until after motion estimation
  738.  
  739. frame_start(s);
  740.  
  741. s->m.current_picture_ptr= &s->m.current_picture;
  742.  
  743.  
  744. gxf_write_map_packet called from:
  745. libavformat/gxfenc.c:752 (gxf_write_header):
  746. gxf->flags |= 0x200000; // time code track is non-drop frame
  747.  
  748. gxf_write_map_packet(s, 0);
  749. gxf_write_flt_packet(s);
  750. gxf_write_umf_packet(s);
  751.  
  752. libavformat/gxfenc.c:783 (gxf_write_trailer):
  753. avio_seek(pb, 0, SEEK_SET);
  754. /* overwrite map, flt and umf packets with new values */
  755. gxf_write_map_packet(s, 1);
  756. gxf_write_flt_packet(s);
  757. gxf_write_umf_packet(s);
  758.  
  759. libavformat/gxfenc.c:790 (gxf_write_trailer):
  760. for (i = 1; i < gxf->map_offsets_nb; i++) {
  761. avio_seek(pb, gxf->map_offsets[i], SEEK_SET);
  762. gxf_write_map_packet(s, 1);
  763. avio_flush(pb);
  764. }
  765.  
  766. libavformat/gxfenc.c:896 (gxf_write_packet):
  767. gxf->packet_count++;
  768. if (gxf->packet_count == 100) {
  769. gxf_write_map_packet(s, 0);
  770. gxf->packet_count = 0;
  771. }
  772.  
  773.  
  774. lag_decode_arith_plane called from:
  775. libavcodec/lagarith.c:469 (lag_decode_frame):
  776. }
  777.  
  778. lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
  779. p->linesize[0], buf + offset_ry,
  780. buf_size);
  781.  
  782. libavcodec/lagarith.c:472 (lag_decode_frame):
  783. p->linesize[0], buf + offset_ry,
  784. buf_size);
  785. lag_decode_arith_plane(l, p->data[2], avctx->width / 2,
  786. avctx->height / 2, p->linesize[2],
  787. buf + offset_gu, buf_size);
  788.  
  789. libavcodec/lagarith.c:475 (lag_decode_frame):
  790. avctx->height / 2, p->linesize[2],
  791. buf + offset_gu, buf_size);
  792. lag_decode_arith_plane(l, p->data[1], avctx->width / 2,
  793. avctx->height / 2, p->linesize[1],
  794. buf + offset_bv, buf_size);
  795.  
  796.  
  797. load_matrix called from:
  798. libavcodec/mpeg12.c:2017 (decode_chunks):
  799. /* get matrix */
  800. if (get_bits1(&s->gb)) {
  801. load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
  802. } else {
  803. for(i=0;i<64;i++) {
  804.  
  805. libavcodec/mpeg12.c:2027 (decode_chunks):
  806. }
  807. if (get_bits1(&s->gb)) {
  808. load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
  809. } else {
  810. for(i=0;i<64;i++) {
  811.  
  812.  
  813. mms_close called from:
  814. libavformat/mmst.c:578 (mms_open):
  815. return 0;
  816. fail:
  817. mms_close(h);
  818. av_dlog(NULL, "Leaving open (failure: %d)\n", err);
  819. return err;
  820.  
  821.  
  822. mov_write_mdia_tag called from:
  823. libavformat/movenc.c:1390 (mov_write_trailer):
  824. if (track->tref_tag)
  825. mov_write_tref_tag(pb, track);
  826. mov_write_mdia_tag(pb, track);
  827. if (track->mode == MODE_PSP)
  828. mov_write_uuid_tag_psp(pb,track); // PSP Movies require this uuid box
  829.  
  830.  
  831. read_braindead_odml_indx called from:
  832. libavformat/avidec.c:671 (avi_read_header):
  833. i= avio_tell(pb);
  834. if(pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX)){
  835. read_braindead_odml_indx(s, 0);
  836. }
  837. avio_seek(pb, i+size, SEEK_SET);
  838.  
  839.  
  840. rtsp_read_play called from:
  841. libavformat/rtspdec.c:310 (rtsp_read_packet):
  842.  
  843. if (rt->state == RTSP_STATE_STREAMING)
  844. rtsp_read_play (s);
  845. }
  846. }
  847.  
  848.  
  849. set_default_channel_config called from:
  850. libavcodec/aacdec.c:595 (aac_decode_init):
  851.  
  852. if (ac->m4ac.chan_config) {
  853. set_default_channel_config(avctx, new_che_pos, ac->m4ac.chan_config);
  854. output_configure(ac, ac->che_pos, new_che_pos, ac->m4ac.chan_config, OC_GLOBAL_HDR);
  855. }
  856.  
  857.  
  858. smacker_decode_bigtree called from:
  859. libavcodec/smacker.c:254 (smacker_decode_header_tree):
  860. huff.values = av_mallocz(huff.length * sizeof(int));
  861.  
  862. smacker_decode_bigtree(gb, &huff, &ctx);
  863. skip_bits1(gb);
  864. if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
  865.  
  866.  
  867. smacker_decode_tree called from:
  868. libavcodec/smacker.c:205 (smacker_decode_header_tree):
  869.  
  870. if(get_bits1(gb)) {
  871. smacker_decode_tree(gb, &tmp1, 0, 0);
  872. skip_bits1(gb);
  873. res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length,
  874.  
  875. libavcodec/smacker.c:218 (smacker_decode_header_tree):
  876. }
  877. if(get_bits1(gb)){
  878. smacker_decode_tree(gb, &tmp2, 0, 0);
  879. skip_bits1(gb);
  880. res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length,
  881.  
  882.  
  883. vc1_decode_entry_point called from:
  884. libavcodec/vc1dec.c:3640 (vc1_decode_frame):
  885. buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
  886. init_get_bits(&s->gb, buf2, buf_size2*8);
  887. vc1_decode_entry_point(avctx, v, &s->gb);
  888. break;
  889. case VC1_CODE_SLICE: {
  890.  
  891.  
  892. vc1_decode_intra_block called from:
  893. libavcodec/vc1dec.c:2551 (vc1_decode_p_blocks):
  894. v->c_avail = v->mb_type[0][s->block_index[i] - 1];
  895.  
  896. vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
  897. if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
  898. v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
  899.  
  900. libavcodec/vc1dec.c:2654 (vc1_decode_p_blocks):
  901. v->c_avail = v->mb_type[0][s->block_index[i] - 1];
  902.  
  903. vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
  904. if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
  905. v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
  906.  
  907. libavcodec/vc1dec.c:2831 (vc1_decode_b_mb):
  908. v->c_avail = v->mb_type[0][s->block_index[i] - 1];
  909.  
  910. vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
  911. if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
  912. v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
  913.  
  914.  
  915. vc1_parse_frame_header_adv called from:
  916. libavcodec/vc1dec.c:3745 (vc1_decode_frame):
  917. for (i = 0; i <= n_slices; i++) {
  918. if (i && get_bits1(&s->gb))
  919. vc1_parse_frame_header_adv(v, &s->gb);
  920. s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start);
  921. s->end_mb_y = (i == n_slices) ? s->mb_height : FFMIN(s->mb_height, slices[i].mby_start);
  922.  
  923.  
  924. write_headers called from:
  925. libavformat/nutenc.c:709 (write_packet):
  926.  
  927. if(1LL<<(20+3*nut->header_count) <= avio_tell(bc))
  928. write_headers(s, bc);
  929.  
  930. if(key_frame && !(nus->last_flags & FLAG_KEY))
  931.  
  932. libavformat/nutenc.c:853 (write_trailer):
  933.  
  934. while(nut->header_count<3)
  935. write_headers(s, bc);
  936. avio_flush(bc);
  937. ff_nut_free_sp(nut);
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!