Mercurial > libavcodec.hg

comparison dvbsubdec.c @ 5930:8a9716d0ccff libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
cosmetic (remove != 0 / != NULL)
author michael
date Mon, 19 Nov 2007 20:26:35 +0000
parents aaeed46a74fd
children 3bb292a4ae12
comparison
equal deleted inserted replaced
5929:aaeed46a74fd 5930:8a9716d0ccff
232 232
233 static DVBSubObject* get_object(DVBSubContext *ctx, int object_id) 233 static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)
234 { 234 {
235 DVBSubObject *ptr = ctx->object_list; 235 DVBSubObject *ptr = ctx->object_list;
236 236
237 while (ptr != NULL && ptr->id != object_id) { 237 while (ptr && ptr->id != object_id) {
238 ptr = ptr->next; 238 ptr = ptr->next;
239 } 239 }
240 240
241 return ptr; 241 return ptr;
242 } 242 }
243 243
244 static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id) 244 static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)
245 { 245 {
246 DVBSubCLUT *ptr = ctx->clut_list; 246 DVBSubCLUT *ptr = ctx->clut_list;
247 247
248 while (ptr != NULL && ptr->id != clut_id) { 248 while (ptr && ptr->id != clut_id) {
249 ptr = ptr->next; 249 ptr = ptr->next;
250 } 250 }
251 251
252 return ptr; 252 return ptr;
253 } 253 }
254 254
255 static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id) 255 static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)
256 { 256 {
257 DVBSubRegion *ptr = ctx->region_list; 257 DVBSubRegion *ptr = ctx->region_list;
258 258
259 while (ptr != NULL && ptr->id != region_id) { 259 while (ptr && ptr->id != region_id) {
260 ptr = ptr->next; 260 ptr = ptr->next;
261 } 261 }
262 262
263 return ptr; 263 return ptr;
264 } 264 }
266 static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region) 266 static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)
267 { 267 {
268 DVBSubObject *object, *obj2, **obj2_ptr; 268 DVBSubObject *object, *obj2, **obj2_ptr;
269 DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr; 269 DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;
270 270
271 while (region->display_list != NULL) { 271 while (region->display_list) {
272 display = region->display_list; 272 display = region->display_list;
273 273
274 object = get_object(ctx, display->object_id); 274 object = get_object(ctx, display->object_id);
275 275
276 if (object != NULL) { 276 if (object) {
277 obj_disp = object->display_list; 277 obj_disp = object->display_list;
278 obj_disp_ptr = &object->display_list; 278 obj_disp_ptr = &object->display_list;
279 279
280 while (obj_disp != NULL && obj_disp != display) { 280 while (obj_disp && obj_disp != display) {
281 obj_disp_ptr = &obj_disp->object_list_next; 281 obj_disp_ptr = &obj_disp->object_list_next;
282 obj_disp = obj_disp->object_list_next; 282 obj_disp = obj_disp->object_list_next;
283 } 283 }
284 284
285 if (obj_disp) { 285 if (obj_disp) {
287 287
288 if (object->display_list == NULL) { 288 if (object->display_list == NULL) {
289 obj2 = ctx->object_list; 289 obj2 = ctx->object_list;
290 obj2_ptr = &ctx->object_list; 290 obj2_ptr = &ctx->object_list;
291 291
292 while (obj2 != NULL && obj2 != object) { 292 while (obj2 && obj2 != object) {
293 obj2_ptr = &obj2->next; 293 obj2_ptr = &obj2->next;
294 obj2 = obj2->next; 294 obj2 = obj2->next;
295 } 295 }
296 296
297 *obj2_ptr = obj2->next; 297 *obj2_ptr = obj2->next;
311 static void delete_state(DVBSubContext *ctx) 311 static void delete_state(DVBSubContext *ctx)
312 { 312 {
313 DVBSubRegion *region; 313 DVBSubRegion *region;
314 DVBSubCLUT *clut; 314 DVBSubCLUT *clut;
315 315
316 while (ctx->region_list != NULL) 316 while (ctx->region_list)
317 { 317 {
318 region = ctx->region_list; 318 region = ctx->region_list;
319 319
320 ctx->region_list = region->next; 320 ctx->region_list = region->next;
321 321
322 delete_region_display_list(ctx, region); 322 delete_region_display_list(ctx, region);
323 if (region->pbuf != NULL) 323 if (region->pbuf)
324 av_free(region->pbuf); 324 av_free(region->pbuf);
325 325
326 av_free(region); 326 av_free(region);
327 } 327 }
328 328
329 while (ctx->clut_list != NULL) 329 while (ctx->clut_list)
330 { 330 {
331 clut = ctx->clut_list; 331 clut = ctx->clut_list;
332 332
333 ctx->clut_list = clut->next; 333 ctx->clut_list = clut->next;
334 334
335 av_free(clut); 335 av_free(clut);
336 } 336 }
337 337
338 /* Should already be null */ 338 /* Should already be null */
339 if (ctx->object_list != NULL) 339 if (ctx->object_list)
340 av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n"); 340 av_log(0, AV_LOG_ERROR, "Memory deallocation error!\n");
341 } 341 }
342 342
343 static int dvbsub_init_decoder(AVCodecContext *avctx) 343 static int dvbsub_init_decoder(AVCodecContext *avctx)
344 { 344 {
418 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data; 418 DVBSubContext *ctx = (DVBSubContext*) avctx->priv_data;
419 DVBSubRegionDisplay *display; 419 DVBSubRegionDisplay *display;
420 420
421 delete_state(ctx); 421 delete_state(ctx);
422 422
423 while (ctx->display_list != NULL) 423 while (ctx->display_list)
424 { 424 {
425 display = ctx->display_list; 425 display = ctx->display_list;
426 ctx->display_list = display->next; 426 ctx->display_list = display->next;
427 427
428 av_free(display); 428 av_free(display);
444 init_get_bits(&gb, *srcbuf, buf_size << 8); 444 init_get_bits(&gb, *srcbuf, buf_size << 8);
445 445
446 while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) { 446 while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
447 bits = get_bits(&gb, 2); 447 bits = get_bits(&gb, 2);
448 448
449 if (bits != 0) { 449 if (bits) {
450 if (non_mod != 1 || bits != 1) { 450 if (non_mod != 1 || bits != 1) {
451 if (map_table != NULL) 451 if (map_table)
452 *destbuf++ = map_table[bits]; 452 *destbuf++ = map_table[bits];
453 else 453 else
454 *destbuf++ = bits; 454 *destbuf++ = bits;
455 } 455 }
456 pixels_read++; 456 pixels_read++;
461 bits = get_bits(&gb, 2); 461 bits = get_bits(&gb, 2);
462 462
463 if (non_mod == 1 && bits == 1) 463 if (non_mod == 1 && bits == 1)
464 pixels_read += run_length; 464 pixels_read += run_length;
465 else { 465 else {
466 if (map_table != NULL) 466 if (map_table)
467 bits = map_table[bits]; 467 bits = map_table[bits];
468 while (run_length-- > 0 && pixels_read < dbuf_len) { 468 while (run_length-- > 0 && pixels_read < dbuf_len) {
469 *destbuf++ = bits; 469 *destbuf++ = bits;
470 pixels_read++; 470 pixels_read++;
471 } 471 }
479 bits = get_bits(&gb, 2); 479 bits = get_bits(&gb, 2);
480 480
481 if (non_mod == 1 && bits == 1) 481 if (non_mod == 1 && bits == 1)
482 pixels_read += run_length; 482 pixels_read += run_length;
483 else { 483 else {
484 if (map_table != NULL) 484 if (map_table)
485 bits = map_table[bits]; 485 bits = map_table[bits];
486 while (run_length-- > 0 && pixels_read < dbuf_len) { 486 while (run_length-- > 0 && pixels_read < dbuf_len) {
487 *destbuf++ = bits; 487 *destbuf++ = bits;
488 pixels_read++; 488 pixels_read++;
489 } 489 }
493 bits = get_bits(&gb, 2); 493 bits = get_bits(&gb, 2);
494 494
495 if (non_mod == 1 && bits == 1) 495 if (non_mod == 1 && bits == 1)
496 pixels_read += run_length; 496 pixels_read += run_length;
497 else { 497 else {
498 if (map_table != NULL) 498 if (map_table)
499 bits = map_table[bits]; 499 bits = map_table[bits];
500 while (run_length-- > 0 && pixels_read < dbuf_len) { 500 while (run_length-- > 0 && pixels_read < dbuf_len) {
501 *destbuf++ = bits; 501 *destbuf++ = bits;
502 pixels_read++; 502 pixels_read++;
503 } 503 }
504 } 504 }
505 } else if (bits == 1) { 505 } else if (bits == 1) {
506 pixels_read += 2; 506 pixels_read += 2;
507 if (map_table != NULL) 507 if (map_table)
508 bits = map_table[0]; 508 bits = map_table[0];
509 else 509 else
510 bits = 0; 510 bits = 0;
511 if (pixels_read <= dbuf_len) { 511 if (pixels_read <= dbuf_len) {
512 *destbuf++ = bits; 512 *destbuf++ = bits;
515 } else { 515 } else {
516 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3; 516 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
517 return pixels_read; 517 return pixels_read;
518 } 518 }
519 } else { 519 } else {
520 if (map_table != NULL) 520 if (map_table)
521 bits = map_table[0]; 521 bits = map_table[0];
522 else 522 else
523 bits = 0; 523 bits = 0;
524 *destbuf++ = bits; 524 *destbuf++ = bits;
525 pixels_read++; 525 pixels_read++;
526 } 526 }
527 } 527 }
528 } 528 }
529 } 529 }
530 530
531 if (get_bits(&gb, 6) != 0) 531 if (get_bits(&gb, 6))
532 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n"); 532 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
533 533
534 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3; 534 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
535 535
536 return pixels_read; 536 return pixels_read;
549 init_get_bits(&gb, *srcbuf, buf_size << 8); 549 init_get_bits(&gb, *srcbuf, buf_size << 8);
550 550
551 while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) { 551 while (get_bits_count(&gb) < (buf_size << 8) && pixels_read < dbuf_len) {
552 bits = get_bits(&gb, 4); 552 bits = get_bits(&gb, 4);
553 553
554 if (bits != 0) { 554 if (bits) {
555 if (non_mod != 1 || bits != 1) { 555 if (non_mod != 1 || bits != 1) {
556 if (map_table != NULL) 556 if (map_table)
557 *destbuf++ = map_table[bits]; 557 *destbuf++ = map_table[bits];
558 else 558 else
559 *destbuf++ = bits; 559 *destbuf++ = bits;
560 } 560 }
561 pixels_read++; 561 pixels_read++;
569 return pixels_read; 569 return pixels_read;
570 } 570 }
571 571
572 run_length += 2; 572 run_length += 2;
573 573
574 if (map_table != NULL) 574 if (map_table)
575 bits = map_table[0]; 575 bits = map_table[0];
576 else 576 else
577 bits = 0; 577 bits = 0;
578 578
579 while (run_length-- > 0 && pixels_read < dbuf_len) { 579 while (run_length-- > 0 && pixels_read < dbuf_len) {
587 bits = get_bits(&gb, 4); 587 bits = get_bits(&gb, 4);
588 588
589 if (non_mod == 1 && bits == 1) 589 if (non_mod == 1 && bits == 1)
590 pixels_read += run_length; 590 pixels_read += run_length;
591 else { 591 else {
592 if (map_table != NULL) 592 if (map_table)
593 bits = map_table[bits]; 593 bits = map_table[bits];
594 while (run_length-- > 0 && pixels_read < dbuf_len) { 594 while (run_length-- > 0 && pixels_read < dbuf_len) {
595 *destbuf++ = bits; 595 *destbuf++ = bits;
596 pixels_read++; 596 pixels_read++;
597 } 597 }
603 bits = get_bits(&gb, 4); 603 bits = get_bits(&gb, 4);
604 604
605 if (non_mod == 1 && bits == 1) 605 if (non_mod == 1 && bits == 1)
606 pixels_read += run_length; 606 pixels_read += run_length;
607 else { 607 else {
608 if (map_table != NULL) 608 if (map_table)
609 bits = map_table[bits]; 609 bits = map_table[bits];
610 while (run_length-- > 0 && pixels_read < dbuf_len) { 610 while (run_length-- > 0 && pixels_read < dbuf_len) {
611 *destbuf++ = bits; 611 *destbuf++ = bits;
612 pixels_read++; 612 pixels_read++;
613 } 613 }
617 bits = get_bits(&gb, 4); 617 bits = get_bits(&gb, 4);
618 618
619 if (non_mod == 1 && bits == 1) 619 if (non_mod == 1 && bits == 1)
620 pixels_read += run_length; 620 pixels_read += run_length;
621 else { 621 else {
622 if (map_table != NULL) 622 if (map_table)
623 bits = map_table[bits]; 623 bits = map_table[bits];
624 while (run_length-- > 0 && pixels_read < dbuf_len) { 624 while (run_length-- > 0 && pixels_read < dbuf_len) {
625 *destbuf++ = bits; 625 *destbuf++ = bits;
626 pixels_read++; 626 pixels_read++;
627 } 627 }
628 } 628 }
629 } else if (bits == 1) { 629 } else if (bits == 1) {
630 pixels_read += 2; 630 pixels_read += 2;
631 if (map_table != NULL) 631 if (map_table)
632 bits = map_table[0]; 632 bits = map_table[0];
633 else 633 else
634 bits = 0; 634 bits = 0;
635 if (pixels_read <= dbuf_len) { 635 if (pixels_read <= dbuf_len) {
636 *destbuf++ = bits; 636 *destbuf++ = bits;
637 *destbuf++ = bits; 637 *destbuf++ = bits;
638 } 638 }
639 } else { 639 } else {
640 if (map_table != NULL) 640 if (map_table)
641 bits = map_table[0]; 641 bits = map_table[0];
642 else 642 else
643 bits = 0; 643 bits = 0;
644 *destbuf++ = bits; 644 *destbuf++ = bits;
645 pixels_read ++; 645 pixels_read ++;
647 } 647 }
648 } 648 }
649 } 649 }
650 } 650 }
651 651
652 if (get_bits(&gb, 8) != 0) 652 if (get_bits(&gb, 8))
653 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n"); 653 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
654 654
655 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3; 655 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;
656 656
657 return pixels_read; 657 return pixels_read;
667 int pixels_read = 0; 667 int pixels_read = 0;
668 668
669 while (*srcbuf < sbuf_end && pixels_read < dbuf_len) { 669 while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {
670 bits = *(*srcbuf)++; 670 bits = *(*srcbuf)++;
671 671
672 if (bits != 0) { 672 if (bits) {
673 if (non_mod != 1 || bits != 1) { 673 if (non_mod != 1 || bits != 1) {
674 if (map_table != NULL) 674 if (map_table)
675 *destbuf++ = map_table[bits]; 675 *destbuf++ = map_table[bits];
676 else 676 else
677 *destbuf++ = bits; 677 *destbuf++ = bits;
678 } 678 }
679 pixels_read++; 679 pixels_read++;
683 if ((bits & 0x80) == 0) { 683 if ((bits & 0x80) == 0) {
684 if (run_length == 0) { 684 if (run_length == 0) {
685 return pixels_read; 685 return pixels_read;
686 } 686 }
687 687
688 if (map_table != NULL) 688 if (map_table)
689 bits = map_table[0]; 689 bits = map_table[0];
690 else 690 else
691 bits = 0; 691 bits = 0;
692 while (run_length-- > 0 && pixels_read < dbuf_len) { 692 while (run_length-- > 0 && pixels_read < dbuf_len) {
693 *destbuf++ = bits; 693 *destbuf++ = bits;
696 } else { 696 } else {
697 bits = *(*srcbuf)++; 697 bits = *(*srcbuf)++;
698 698
699 if (non_mod == 1 && bits == 1) 699 if (non_mod == 1 && bits == 1)
700 pixels_read += run_length; 700 pixels_read += run_length;
701 if (map_table != NULL) 701 if (map_table)
702 bits = map_table[bits]; 702 bits = map_table[bits];
703 else while (run_length-- > 0 && pixels_read < dbuf_len) { 703 else while (run_length-- > 0 && pixels_read < dbuf_len) {
704 *destbuf++ = bits; 704 *destbuf++ = bits;
705 pixels_read++; 705 pixels_read++;
706 } 706 }
707 } 707 }
708 } 708 }
709 } 709 }
710 710
711 if (*(*srcbuf)++ != 0) 711 if (*(*srcbuf)++)
712 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n"); 712 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");
713 713
714 return pixels_read; 714 return pixels_read;
715 } 715 }
716 716
747 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]); 747 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
748 if (i % 16 == 15) 748 if (i % 16 == 15)
749 av_log(avctx, AV_LOG_INFO, "\n"); 749 av_log(avctx, AV_LOG_INFO, "\n");
750 } 750 }
751 751
752 if (i % 16 != 0) 752 if (i % 16)
753 av_log(avctx, AV_LOG_INFO, "\n"); 753 av_log(avctx, AV_LOG_INFO, "\n");
754 754
755 #endif 755 #endif
756 756
757 if (region == 0) 757 if (region == 0)
870 if (buf + top_field_len + bottom_field_len > buf_end) { 870 if (buf + top_field_len + bottom_field_len > buf_end) {
871 av_log(avctx, AV_LOG_ERROR, "Field data size too large\n"); 871 av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");
872 return; 872 return;
873 } 873 }
874 874
875 for (display = object->display_list; display != 0; display = display->object_list_next) { 875 for (display = object->display_list; display; display = display->object_list_next) {
876 block = buf; 876 block = buf;
877 877
878 dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0, 878 dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,
879 non_modifying_colour); 879 non_modifying_colour);
880 880
917 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]); 917 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
918 if (i % 16 == 15) 918 if (i % 16 == 15)
919 av_log(avctx, AV_LOG_INFO, "\n"); 919 av_log(avctx, AV_LOG_INFO, "\n");
920 } 920 }
921 921
922 if (i % 16 != 0) 922 if (i % 16)
923 av_log(avctx, AV_LOG_INFO, "\n"); 923 av_log(avctx, AV_LOG_INFO, "\n");
924 924
925 #endif 925 #endif
926 926
927 clut_id = *buf++; 927 clut_id = *buf++;
1022 buf += 2; 1022 buf += 2;
1023 region->height = AV_RB16(buf); 1023 region->height = AV_RB16(buf);
1024 buf += 2; 1024 buf += 2;
1025 1025
1026 if (region->width * region->height != region->buf_size) { 1026 if (region->width * region->height != region->buf_size) {
1027 if (region->pbuf != 0) 1027 if (region->pbuf)
1028 av_free(region->pbuf); 1028 av_free(region->pbuf);
1029 1029
1030 region->buf_size = region->width * region->height; 1030 region->buf_size = region->width * region->height;
1031 1031
1032 region->pbuf = av_malloc(region->buf_size); 1032 region->pbuf = av_malloc(region->buf_size);
1139 buf += 1; 1139 buf += 1;
1140 1140
1141 display = tmp_display_list; 1141 display = tmp_display_list;
1142 tmp_ptr = &tmp_display_list; 1142 tmp_ptr = &tmp_display_list;
1143 1143
1144 while (display != NULL && display->region_id != region_id) { 1144 while (display && display->region_id != region_id) {
1145 tmp_ptr = &display->next; 1145 tmp_ptr = &display->next;
1146 display = display->next; 1146 display = display->next;
1147 } 1147 }
1148 1148
1149 if (display == NULL) 1149 if (display == NULL)
1165 #ifdef DEBUG 1165 #ifdef DEBUG
1166 av_log(avctx, AV_LOG_INFO, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos); 1166 av_log(avctx, AV_LOG_INFO, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);
1167 #endif 1167 #endif
1168 } 1168 }
1169 1169
1170 while (tmp_display_list != 0) { 1170 while (tmp_display_list) {
1171 display = tmp_display_list; 1171 display = tmp_display_list;
1172 1172
1173 tmp_display_list = display->next; 1173 tmp_display_list = display->next;
1174 1174
1175 av_free(display); 1175 av_free(display);
1194 x_pos = -1; 1194 x_pos = -1;
1195 y_pos = -1; 1195 y_pos = -1;
1196 width = 0; 1196 width = 0;
1197 height = 0; 1197 height = 0;
1198 1198
1199 for (display = ctx->display_list; display != NULL; display = display->next) { 1199 for (display = ctx->display_list; display; display = display->next) {
1200 region = get_region(ctx, display->region_id); 1200 region = get_region(ctx, display->region_id);
1201 1201
1202 if (x_pos == -1) { 1202 if (x_pos == -1) {
1203 x_pos = display->x_pos; 1203 x_pos = display->x_pos;
1204 y_pos = display->y_pos; 1204 y_pos = display->y_pos;
1227 1227
1228 if (x_pos >= 0) { 1228 if (x_pos >= 0) {
1229 1229
1230 pbuf = av_malloc(width * height * 4); 1230 pbuf = av_malloc(width * height * 4);
1231 1231
1232 for (display = ctx->display_list; display != NULL; display = display->next) { 1232 for (display = ctx->display_list; display; display = display->next) {
1233 region = get_region(ctx, display->region_id); 1233 region = get_region(ctx, display->region_id);
1234 1234
1235 x_off = display->x_pos - x_pos; 1235 x_off = display->x_pos - x_pos;
1236 y_off = display->y_pos - y_pos; 1236 y_off = display->y_pos - y_pos;
1237 1237
1295 if (sub->num_rects > 0) 1295 if (sub->num_rects > 0)
1296 sub->rects = av_mallocz(sizeof(AVSubtitleRect) * sub->num_rects); 1296 sub->rects = av_mallocz(sizeof(AVSubtitleRect) * sub->num_rects);
1297 1297
1298 i = 0; 1298 i = 0;
1299 1299
1300 for (display = ctx->display_list; display != NULL; display = display->next) { 1300 for (display = ctx->display_list; display; display = display->next) {
1301 region = get_region(ctx, display->region_id); 1301 region = get_region(ctx, display->region_id);
1302 rect = &sub->rects[i]; 1302 rect = &sub->rects[i];
1303 1303
1304 if (region == NULL) 1304 if (region == NULL)
1305 continue; 1305 continue;
1368 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]); 1368 av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
1369 if (i % 16 == 15) 1369 if (i % 16 == 15)
1370 av_log(avctx, AV_LOG_INFO, "\n"); 1370 av_log(avctx, AV_LOG_INFO, "\n");
1371 } 1371 }
1372 1372
1373 if (i % 16 != 0) 1373 if (i % 16)
1374 av_log(avctx, AV_LOG_INFO, "\n"); 1374 av_log(avctx, AV_LOG_INFO, "\n");
1375 1375
1376 #endif 1376 #endif
1377 1377
1378 if (buf_size <= 2) 1378 if (buf_size <= 2)