xine+vidix: Bild croppen?

Hi,

kann mir jemand verraten, wie ich ich mit xine (1.1.1) bei Ausgabe über vidix (unter X) das Bild croppen und hochskalieren kann? Mir geht es darum, jeweils an den Rändern ein paar Pixel wegzuschneiden (wegen der Störungen) und das Bild dann wieder auf eine Breite von 720 zu dehnen. Ich habe mal irgendwo etwas gelesen, dass des dazu mal einen Bug gab (ich meine es war ein Beitrag von rnissl, aber es war nicht hier im Board sondern auf der ML; allerdings habe ich da nichts gefunden, wie man es überhaupt aufruft).

Also:
Kennt jemand den Aufruf für xine, so á la: "xine --post expand:crop_top=x,crop_bottom=y......"?? Mit expand geht's natürlich nicht, aber vielleicht gibt's da ja doch irgendwas?

Gruß,
Holger

keiner eine Idee? Hier gibt es doch einige Xine-Nutzer... und ich bin der einzige, den die VBI-Störungen nerven?

Ich lese in den Announcements zu xine-lib >1 ständig irgendwas von "added cropping support for..." aber nirgends finde ich einen Hinweis darauf, wie man es aktiviert.

Oder sollte sich das alles immer nur auf den "center_cut_out" Mode beziehen? Kann man bei xine nicht mal eben ein paar Pixel vom Bild wegschnippeln? Was dem softdevice recht ist, sollte doch einem "Monster" wie xine nur billig sein, oder?

Viele Grüße,
Holger

Zitat

Original von sparkie
warum benutzt du nicht die zahlreichen Zoomfunktionen von xine, um ungewuenschtes
auszublenden?

-sparkie

Nun ja.... weil ich keine Tastatur angeschlossen habe z.B. Ich möchte auch eigentlich garnicht wirklich zoomen. Das Bild wird auf ein 4:3 Display ausgegeben. Schwarze Balken oben und unten stören mich nicht. Und ich möchte auch eigentlich nicht dauernd irgendwas drücken müssen beim zappen Oder gibt es einen "allgemeingültigen" Zoom für meine Konstellation?

Gruß,
Holger

Profi bei der Arbeit. Danke für die Antwort!

Zitat

Original von rnissl
Hhm, also wenn ich das jetzt richtig verstanden habe, möchtest du bei einer 16:9 (oder auch 4:3) Übertragung z. B. von ZDF die eine VBI-Zeile wegschneiden.

Exakt. Genau *das* ist es, was ich möchte. Bei 4:3 oder LB Sendungen stört es mich nur wenig; da kann ich glücklicherweise das Bild am Fernseher ein Zeile nach oben schieben. Bei anamorphen Sendungen hingegegen gibt's halt diese lästigen weissen Biester. Besonders "hübsch" wenn das Quellmaterial in 2.35:1 ist: Dann gibt's kleine, zitternde, weisse Balken mitten im schwarzen Bereich.

Zitat

Also, es sieht wohl so aus, als müsstest du Hand an den Source anlegen. Evtl. fill.c als Grundlage nehmen und statt crop_left, crop_right und aspect zu ändern, einfach nur crop_top erhöhen.

Danke für den Tipp. Geht scheinbar wirklich nicht einfacher. Tja.... nun habe ich leider wenig Plan davon. Mittlerweile bilde ich mir ein, Code wenigstens *lesen* zu können; mit dem *schreiben* wird's aber wohl vorerst noch nichts.

Nun ist die "fill.c" glücklicherweise recht übersichtlich, eignet sich also wohl wirklich für einen Einstieg. Wenn mich aber doch irgendwer dabei unterstützen könnte, wäre ich extrem dankbar!

Sie sieht die "fill.c" aus:

#include "xine_internal.h"
#include "post.h"


/* plugin class initialization function */
void *fill_init_plugin(xine_t *xine, void *);


/* plugin class functions */
static post_plugin_t *fill_open_plugin(post_class_t *class_gen, int inputs,
                                       xine_audio_port_t **audio_target,
                                       xine_video_port_t **video_target);
static char          *fill_get_identifier(post_class_t *class_gen);
static char          *fill_get_description(post_class_t *class_gen);
static void           fill_class_dispose(post_class_t *class_gen);


/* plugin instance functions */
static void           fill_dispose(post_plugin_t *this_gen);


/* replaced video port functions */
static vo_frame_t    *fill_get_frame(xine_video_port_t *port_gen, uint32_t width,
                                     uint32_t height, double ratio,
                                     int format, int flags);
static int            fill_draw(vo_frame_t *frame, xine_stream_t *stream);




void *fill_init_plugin(xine_t *xine, void *data)
{
  post_class_t *class = (post_class_t *)malloc(sizeof(post_class_t));

  if (!class)
    return NULL;

  class->open_plugin     = fill_open_plugin;
  class->get_identifier  = fill_get_identifier;
  class->get_description = fill_get_description;
  class->dispose         = fill_class_dispose;

  return class;
}




static post_plugin_t *fill_open_plugin(post_class_t *class_gen, int inputs,
					 xine_audio_port_t **audio_target,
					 xine_video_port_t **video_target)
{
  post_plugin_t     *this        = (post_plugin_t *)xine_xmalloc(sizeof(post_plugin_t));
  post_in_t         *input;
  post_out_t        *output;
  post_video_port_t *port;

  if (!this || !video_target || !video_target[0]) {
    free(this);
    return NULL;
  }

  _x_post_init(this, 0, 1);

  port = _x_post_intercept_video_port(this, video_target[0], &input, &output);
  port->new_port.get_frame = fill_get_frame;
  port->new_frame->draw    = fill_draw;

  input->xine_in.name     = "video";
  output->xine_out.name   = "cropped video";

  this->xine_post.video_input[0] = &port->new_port;

  this->dispose = fill_dispose;

  return this;
}


static char *fill_get_identifier(post_class_t *class_gen)
{
  return "fill";
}


static char *fill_get_description(post_class_t *class_gen)
{
  return "crops left and right of video to fill 4:3 aspect ratio";
}


static void fill_class_dispose(post_class_t *class_gen)
{
  free(class_gen);
}


static void fill_dispose(post_plugin_t *this)
{
  if (_x_post_dispose(this))
    free(this);
}




static vo_frame_t *fill_get_frame(xine_video_port_t *port_gen, uint32_t width, 
                                  uint32_t height, double ratio, 
                                  int format, int flags)
{
  post_video_port_t *port = (post_video_port_t *)port_gen;
  post_plugin_t     *this = port->post;
  vo_frame_t        *frame;

  _x_post_rewire(this);

  if (ratio <= 0.0) ratio = (double)width / (double)height;

  if ((ratio > 4.0/3.0) &&
      (format == XINE_IMGFMT_YV12 || format == XINE_IMGFMT_YUY2)) {
    frame = port->original_port->get_frame(port->original_port,
      width, height, 4.0/3.0, format, flags);

    _x_post_inc_usage(port);
    frame = _x_post_intercept_video_frame(frame, port);

    frame->ratio = ratio;
  } else {
    frame = port->original_port->get_frame(port->original_port,
      width, height, ratio, format, flags);
    /* no need to intercept this one, we are not going to do anything with it */
  }

  return frame;
}




static int fill_draw(vo_frame_t *frame, xine_stream_t *stream)
{
  int skip, new_width;

  new_width = (4.0*frame->width) / (3.0*frame->ratio);

  frame->crop_left += (frame->width - new_width) / 2;
  frame->crop_right += (frame->width + 1 - new_width) / 2;
  frame->ratio = 4.0/3.0;

  _x_post_frame_copy_down(frame, frame->next);
  skip = frame->next->draw(frame->next, stream);
  _x_post_frame_copy_up(frame, frame->next);
  return skip;
}

Viele Grüße,
Holger

Zitat

Original von rnissl
Hi,

was noch fehlt, ist ein Eintrag für "egon.c" in Makefile.am. Einfach vor oder hinter fill.c dazuschreiben.

Und auch in planar.c sind noch 3 Zeilen zu ergänzen, die durch "aufdoppeln" der Zeilen mit "fill" und umbennen erzeugt werden können.

Bye.

Alles anzeigen

Hi Reinhard,

vielen Dank für deine Unterstützung! Das mit dem Makefile hatte ich mir bereits gedacht, als ich mir die Frage gestellt habe, woher xine denn nun beim Neubauen von der Existenz von "Egon" erfahren soll. Die nächste Frage die sich mir dann stellte war: Woher weiß xine dass es "Egon" denn nun auch verwenden soll? -> das scheint dann also das Ändern der planar.c zu bewerkstelligen.

Wie du siehst: Ich bin diesbzgl. ein Noob... daher habe ich auch noch eine kleine Frage: Was meinst du mit "abrunden"?

Viele Grüße und danke für die Geduld,
Holger

PS: Gestern habe ich das ganze nur theoretisch durchgespielt; heute abend geht's "ran"

Ahhhhh.. danke! Dann kann's ja jetzt losgehen!

Gruß,
Holger